001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.util;
016    
017    import com.liferay.portal.NoSuchGroupException;
018    import com.liferay.portal.NoSuchImageException;
019    import com.liferay.portal.NoSuchLayoutException;
020    import com.liferay.portal.NoSuchUserException;
021    import com.liferay.portal.dao.orm.common.SQLTransformer;
022    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
023    import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
024    import com.liferay.portal.kernel.cluster.ClusterInvokeThreadLocal;
025    import com.liferay.portal.kernel.cluster.ClusterRequest;
026    import com.liferay.portal.kernel.concurrent.ConcurrentHashSet;
027    import com.liferay.portal.kernel.dao.db.DB;
028    import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
029    import com.liferay.portal.kernel.dao.orm.QueryUtil;
030    import com.liferay.portal.kernel.exception.PortalException;
031    import com.liferay.portal.kernel.exception.SystemException;
032    import com.liferay.portal.kernel.language.LanguageUtil;
033    import com.liferay.portal.kernel.log.Log;
034    import com.liferay.portal.kernel.log.LogFactoryUtil;
035    import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
036    import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
037    import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
038    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
039    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
040    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
041    import com.liferay.portal.kernel.portlet.LiferayPortletURL;
042    import com.liferay.portal.kernel.portlet.LiferayWindowState;
043    import com.liferay.portal.kernel.portlet.PortletBag;
044    import com.liferay.portal.kernel.portlet.PortletBagPool;
045    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
046    import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
047    import com.liferay.portal.kernel.servlet.DynamicServletRequest;
048    import com.liferay.portal.kernel.servlet.HttpHeaders;
049    import com.liferay.portal.kernel.servlet.HttpMethods;
050    import com.liferay.portal.kernel.servlet.NonSerializableObjectRequestWrapper;
051    import com.liferay.portal.kernel.servlet.PersistentHttpServletRequestWrapper;
052    import com.liferay.portal.kernel.servlet.PortalMessages;
053    import com.liferay.portal.kernel.servlet.PortalSessionThreadLocal;
054    import com.liferay.portal.kernel.servlet.ServletContextUtil;
055    import com.liferay.portal.kernel.servlet.SessionErrors;
056    import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
057    import com.liferay.portal.kernel.upload.UploadPortletRequest;
058    import com.liferay.portal.kernel.upload.UploadServletRequest;
059    import com.liferay.portal.kernel.util.ArrayUtil;
060    import com.liferay.portal.kernel.util.Base64;
061    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
062    import com.liferay.portal.kernel.util.CharPool;
063    import com.liferay.portal.kernel.util.ContentTypes;
064    import com.liferay.portal.kernel.util.ContextPathUtil;
065    import com.liferay.portal.kernel.util.CookieKeys;
066    import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
067    import com.liferay.portal.kernel.util.GetterUtil;
068    import com.liferay.portal.kernel.util.HtmlUtil;
069    import com.liferay.portal.kernel.util.Http;
070    import com.liferay.portal.kernel.util.HttpUtil;
071    import com.liferay.portal.kernel.util.InheritableMap;
072    import com.liferay.portal.kernel.util.JavaConstants;
073    import com.liferay.portal.kernel.util.ListMergeable;
074    import com.liferay.portal.kernel.util.ListUtil;
075    import com.liferay.portal.kernel.util.LocaleUtil;
076    import com.liferay.portal.kernel.util.LocalizationUtil;
077    import com.liferay.portal.kernel.util.MethodHandler;
078    import com.liferay.portal.kernel.util.MethodKey;
079    import com.liferay.portal.kernel.util.ParamUtil;
080    import com.liferay.portal.kernel.util.PropsKeys;
081    import com.liferay.portal.kernel.util.ReleaseInfo;
082    import com.liferay.portal.kernel.util.ResourceBundleUtil;
083    import com.liferay.portal.kernel.util.ServerDetector;
084    import com.liferay.portal.kernel.util.StringBundler;
085    import com.liferay.portal.kernel.util.StringComparator;
086    import com.liferay.portal.kernel.util.StringPool;
087    import com.liferay.portal.kernel.util.StringUtil;
088    import com.liferay.portal.kernel.util.Time;
089    import com.liferay.portal.kernel.util.UnicodeProperties;
090    import com.liferay.portal.kernel.util.UniqueList;
091    import com.liferay.portal.kernel.util.Validator;
092    import com.liferay.portal.kernel.xml.QName;
093    import com.liferay.portal.model.AuditedModel;
094    import com.liferay.portal.model.BaseModel;
095    import com.liferay.portal.model.ClassName;
096    import com.liferay.portal.model.ColorScheme;
097    import com.liferay.portal.model.Company;
098    import com.liferay.portal.model.Group;
099    import com.liferay.portal.model.GroupConstants;
100    import com.liferay.portal.model.Layout;
101    import com.liferay.portal.model.LayoutConstants;
102    import com.liferay.portal.model.LayoutFriendlyURLComposite;
103    import com.liferay.portal.model.LayoutQueryStringComposite;
104    import com.liferay.portal.model.LayoutSet;
105    import com.liferay.portal.model.LayoutType;
106    import com.liferay.portal.model.LayoutTypePortlet;
107    import com.liferay.portal.model.LayoutTypePortletConstants;
108    import com.liferay.portal.model.Organization;
109    import com.liferay.portal.model.Portlet;
110    import com.liferay.portal.model.PortletConstants;
111    import com.liferay.portal.model.PublicRenderParameter;
112    import com.liferay.portal.model.ResourceConstants;
113    import com.liferay.portal.model.ResourcePermission;
114    import com.liferay.portal.model.Role;
115    import com.liferay.portal.model.RoleConstants;
116    import com.liferay.portal.model.Theme;
117    import com.liferay.portal.model.Ticket;
118    import com.liferay.portal.model.TicketConstants;
119    import com.liferay.portal.model.User;
120    import com.liferay.portal.model.UserGroup;
121    import com.liferay.portal.model.VirtualHost;
122    import com.liferay.portal.model.VirtualLayoutConstants;
123    import com.liferay.portal.model.impl.CookieRemotePreference;
124    import com.liferay.portal.model.impl.LayoutTypePortletImpl;
125    import com.liferay.portal.model.impl.VirtualLayout;
126    import com.liferay.portal.plugin.PluginPackageUtil;
127    import com.liferay.portal.security.auth.AuthException;
128    import com.liferay.portal.security.auth.AuthTokenUtil;
129    import com.liferay.portal.security.auth.AuthTokenWhitelistUtil;
130    import com.liferay.portal.security.auth.CompanyThreadLocal;
131    import com.liferay.portal.security.auth.FullNameGenerator;
132    import com.liferay.portal.security.auth.FullNameGeneratorFactory;
133    import com.liferay.portal.security.auth.PrincipalException;
134    import com.liferay.portal.security.jaas.JAASHelper;
135    import com.liferay.portal.security.lang.DoPrivilegedUtil;
136    import com.liferay.portal.security.permission.ActionKeys;
137    import com.liferay.portal.security.permission.PermissionChecker;
138    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
139    import com.liferay.portal.security.permission.ResourceActionsUtil;
140    import com.liferay.portal.service.ClassNameLocalServiceUtil;
141    import com.liferay.portal.service.CompanyLocalServiceUtil;
142    import com.liferay.portal.service.GroupLocalServiceUtil;
143    import com.liferay.portal.service.GroupServiceUtil;
144    import com.liferay.portal.service.LayoutLocalServiceUtil;
145    import com.liferay.portal.service.LayoutSetLocalServiceUtil;
146    import com.liferay.portal.service.PortletLocalServiceUtil;
147    import com.liferay.portal.service.ResourceLocalServiceUtil;
148    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
149    import com.liferay.portal.service.TicketLocalServiceUtil;
150    import com.liferay.portal.service.UserLocalServiceUtil;
151    import com.liferay.portal.service.UserServiceUtil;
152    import com.liferay.portal.service.VirtualHostLocalServiceUtil;
153    import com.liferay.portal.service.permission.GroupPermissionUtil;
154    import com.liferay.portal.service.permission.LayoutPermissionUtil;
155    import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
156    import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
157    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
158    import com.liferay.portal.service.permission.PortletPermissionUtil;
159    import com.liferay.portal.service.permission.UserPermissionUtil;
160    import com.liferay.portal.servlet.filters.i18n.I18nFilter;
161    import com.liferay.portal.servlet.filters.secure.NonceUtil;
162    import com.liferay.portal.spring.context.PortalContextLoaderListener;
163    import com.liferay.portal.struts.StrutsUtil;
164    import com.liferay.portal.theme.PortletDisplay;
165    import com.liferay.portal.theme.ThemeDisplay;
166    import com.liferay.portal.upload.UploadPortletRequestImpl;
167    import com.liferay.portal.upload.UploadServletRequestImpl;
168    import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
169    import com.liferay.portal.webserver.WebServerServlet;
170    import com.liferay.portlet.ActionResponseImpl;
171    import com.liferay.portlet.InvokerPortlet;
172    import com.liferay.portlet.PortletConfigFactoryUtil;
173    import com.liferay.portlet.PortletInstanceFactoryUtil;
174    import com.liferay.portlet.PortletPreferencesFactoryUtil;
175    import com.liferay.portlet.PortletPreferencesImpl;
176    import com.liferay.portlet.PortletPreferencesWrapper;
177    import com.liferay.portlet.PortletQNameUtil;
178    import com.liferay.portlet.PortletRequestImpl;
179    import com.liferay.portlet.PortletResponseImpl;
180    import com.liferay.portlet.PortletURLFactoryUtil;
181    import com.liferay.portlet.RenderRequestImpl;
182    import com.liferay.portlet.RenderResponseImpl;
183    import com.liferay.portlet.StateAwareResponseImpl;
184    import com.liferay.portlet.UserAttributes;
185    import com.liferay.portlet.admin.util.OmniadminUtil;
186    import com.liferay.portlet.asset.model.AssetTag;
187    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
188    import com.liferay.portlet.blogs.model.BlogsEntry;
189    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
190    import com.liferay.portlet.bookmarks.model.BookmarksFolder;
191    import com.liferay.portlet.calendar.model.CalEvent;
192    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
193    import com.liferay.portlet.documentlibrary.model.DLFolder;
194    import com.liferay.portlet.expando.ValueDataException;
195    import com.liferay.portlet.expando.model.ExpandoBridge;
196    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
197    import com.liferay.portlet.journal.NoSuchFeedException;
198    import com.liferay.portlet.journal.asset.JournalArticleAssetRendererFactory;
199    import com.liferay.portlet.journal.model.JournalArticle;
200    import com.liferay.portlet.journal.model.JournalArticleConstants;
201    import com.liferay.portlet.journal.model.JournalFolder;
202    import com.liferay.portlet.journal.service.JournalArticleLocalServiceUtil;
203    import com.liferay.portlet.login.util.LoginUtil;
204    import com.liferay.portlet.messageboards.action.EditDiscussionAction;
205    import com.liferay.portlet.messageboards.model.MBMessage;
206    import com.liferay.portlet.messageboards.model.MBThread;
207    import com.liferay.portlet.sites.util.Sites;
208    import com.liferay.portlet.sites.util.SitesUtil;
209    import com.liferay.portlet.social.model.SocialRelationConstants;
210    import com.liferay.portlet.social.util.FacebookUtil;
211    import com.liferay.portlet.wiki.model.WikiPage;
212    import com.liferay.util.Encryptor;
213    import com.liferay.util.JS;
214    
215    import java.io.IOException;
216    import java.io.Serializable;
217    
218    import java.lang.reflect.Method;
219    
220    import java.net.Inet4Address;
221    import java.net.InetAddress;
222    import java.net.NetworkInterface;
223    import java.net.UnknownHostException;
224    
225    import java.util.ArrayList;
226    import java.util.Arrays;
227    import java.util.Calendar;
228    import java.util.Collection;
229    import java.util.Collections;
230    import java.util.Date;
231    import java.util.Enumeration;
232    import java.util.HashMap;
233    import java.util.HashSet;
234    import java.util.Iterator;
235    import java.util.LinkedHashMap;
236    import java.util.List;
237    import java.util.Locale;
238    import java.util.Map;
239    import java.util.Properties;
240    import java.util.ResourceBundle;
241    import java.util.Set;
242    import java.util.TimeZone;
243    import java.util.TreeSet;
244    import java.util.concurrent.ConcurrentHashMap;
245    import java.util.concurrent.atomic.AtomicInteger;
246    import java.util.regex.Matcher;
247    import java.util.regex.Pattern;
248    
249    import javax.portlet.ActionRequest;
250    import javax.portlet.ActionResponse;
251    import javax.portlet.PortletConfig;
252    import javax.portlet.PortletException;
253    import javax.portlet.PortletMode;
254    import javax.portlet.PortletPreferences;
255    import javax.portlet.PortletRequest;
256    import javax.portlet.PortletResponse;
257    import javax.portlet.PortletURL;
258    import javax.portlet.PreferencesValidator;
259    import javax.portlet.RenderRequest;
260    import javax.portlet.RenderResponse;
261    import javax.portlet.ValidatorException;
262    import javax.portlet.WindowState;
263    
264    import javax.servlet.RequestDispatcher;
265    import javax.servlet.ServletContext;
266    import javax.servlet.ServletException;
267    import javax.servlet.http.Cookie;
268    import javax.servlet.http.HttpServletRequest;
269    import javax.servlet.http.HttpServletRequestWrapper;
270    import javax.servlet.http.HttpServletResponse;
271    import javax.servlet.http.HttpSession;
272    import javax.servlet.jsp.PageContext;
273    
274    import org.apache.struts.Globals;
275    
276    /**
277     * @author Brian Wing Shun Chan
278     * @author Brian Myunghun Kim
279     * @author Jorge Ferrer
280     * @author Raymond Aug??
281     * @author Eduardo Lundgren
282     * @author Wesley Gong
283     * @author Hugo Huijser
284     * @author Juan Fern??ndez
285     */
286    @DoPrivileged
287    public class PortalImpl implements Portal {
288    
289            public PortalImpl() {
290    
291                    // Computer name
292    
293                    _computerName = System.getProperty("env.COMPUTERNAME");
294    
295                    if (Validator.isNull(_computerName)) {
296                            _computerName = System.getProperty("env.HOST");
297                    }
298    
299                    if (Validator.isNull(_computerName)) {
300                            _computerName = System.getProperty("env.HOSTNAME");
301                    }
302    
303                    if (Validator.isNull(_computerName)) {
304                            try {
305                                    InetAddress inetAddress = InetAddress.getLocalHost();
306    
307                                    _computerName = inetAddress.getHostName();
308                            }
309                            catch (UnknownHostException uhe) {
310                            }
311                    }
312    
313                    try {
314                            InetAddress inetAddress = InetAddress.getByName(_computerName);
315    
316                            _computerAddress = inetAddress.getHostAddress();
317                    }
318                    catch (UnknownHostException uhe) {
319                    }
320    
321                    if (Validator.isNull(_computerAddress)) {
322                            try {
323                                    InetAddress inetAddress = InetAddress.getLocalHost();
324    
325                                    _computerAddress = inetAddress.getHostAddress();
326                            }
327                            catch (UnknownHostException uhe) {
328                            }
329                    }
330    
331                    try {
332                            List<NetworkInterface> networkInterfaces = Collections.list(
333                                    NetworkInterface.getNetworkInterfaces());
334    
335                            for (NetworkInterface networkInterface : networkInterfaces) {
336                                    List<InetAddress> inetAddresses = Collections.list(
337                                            networkInterface.getInetAddresses());
338    
339                                    for (InetAddress inetAddress : inetAddresses) {
340                                            if (inetAddress instanceof Inet4Address) {
341                                                    _computerAddresses.add(inetAddress.getHostAddress());
342                                            }
343                                    }
344                            }
345                    }
346                    catch (Exception e) {
347                            _log.error("Unable to determine server's IP addresses");
348    
349                            _log.error(e, e);
350                    }
351    
352                    // Paths
353    
354                    _pathProxy = PropsValues.PORTAL_PROXY_PATH;
355    
356                    _pathContext = ContextPathUtil.getContextPath(
357                            PortalContextLoaderListener.getPortalServletContextPath());
358                    _pathContext = _pathProxy.concat(_pathContext);
359    
360                    _pathFriendlyURLPrivateGroup =
361                            _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
362                    _pathFriendlyURLPrivateUser =
363                            _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
364                    _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
365                    _pathImage = _pathContext + PATH_IMAGE;
366                    _pathMain = _pathContext + PATH_MAIN;
367                    _pathModule = _pathContext + PATH_MODULE;
368    
369                    // Groups
370    
371                    String[] customSystemGroups = PropsUtil.getArray(
372                            PropsKeys.SYSTEM_GROUPS);
373    
374                    if (ArrayUtil.isEmpty(customSystemGroups)) {
375                            _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
376                    }
377                    else {
378                            _allSystemGroups = ArrayUtil.append(
379                                    GroupConstants.SYSTEM_GROUPS, customSystemGroups);
380                    }
381    
382                    _sortedSystemGroups = new String[_allSystemGroups.length];
383    
384                    System.arraycopy(
385                            _allSystemGroups, 0, _sortedSystemGroups, 0,
386                            _allSystemGroups.length);
387    
388                    Arrays.sort(_sortedSystemGroups, new StringComparator());
389    
390                    // Regular roles
391    
392                    String[] customSystemRoles = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
393    
394                    if (ArrayUtil.isEmpty(customSystemRoles)) {
395                            _allSystemRoles = RoleConstants.SYSTEM_ROLES;
396                    }
397                    else {
398                            _allSystemRoles = ArrayUtil.append(
399                                    RoleConstants.SYSTEM_ROLES, customSystemRoles);
400                    }
401    
402                    _sortedSystemRoles = new String[_allSystemRoles.length];
403    
404                    System.arraycopy(
405                            _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
406    
407                    Arrays.sort(_sortedSystemRoles, new StringComparator());
408    
409                    // Organization roles
410    
411                    String[] customSystemOrganizationRoles = PropsUtil.getArray(
412                            PropsKeys.SYSTEM_ORGANIZATION_ROLES);
413    
414                    if (ArrayUtil.isEmpty(customSystemOrganizationRoles)) {
415                            _allSystemOrganizationRoles =
416                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES;
417                    }
418                    else {
419                            _allSystemOrganizationRoles = ArrayUtil.append(
420                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES,
421                                    customSystemOrganizationRoles);
422                    }
423    
424                    _sortedSystemOrganizationRoles =
425                            new String[_allSystemOrganizationRoles.length];
426    
427                    System.arraycopy(
428                            _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
429                            _allSystemOrganizationRoles.length);
430    
431                    Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
432    
433                    // Site roles
434    
435                    String[] customSystemSiteRoles = PropsUtil.getArray(
436                            PropsKeys.SYSTEM_SITE_ROLES);
437    
438                    if (ArrayUtil.isEmpty(customSystemSiteRoles)) {
439                            _allSystemSiteRoles = RoleConstants.SYSTEM_SITE_ROLES;
440                    }
441                    else {
442                            _allSystemSiteRoles = ArrayUtil.append(
443                                    RoleConstants.SYSTEM_SITE_ROLES, customSystemSiteRoles);
444                    }
445    
446                    _sortedSystemSiteRoles = new String[_allSystemSiteRoles.length];
447    
448                    System.arraycopy(
449                            _allSystemSiteRoles, 0, _sortedSystemSiteRoles, 0,
450                            _allSystemSiteRoles.length);
451    
452                    Arrays.sort(_sortedSystemSiteRoles, new StringComparator());
453    
454                    // Reserved parameter names
455    
456                    _reservedParams = new HashSet<String>();
457    
458                    // Portal authentication
459    
460                    _reservedParams.add("p_auth");
461                    _reservedParams.add("p_auth_secret");
462    
463                    // Portal layout
464    
465                    _reservedParams.add("p_l_id");
466                    _reservedParams.add("p_l_reset");
467    
468                    // Portal portlet
469    
470                    _reservedParams.add("p_p_auth");
471                    _reservedParams.add("p_p_id");
472                    _reservedParams.add("p_p_i_id");
473                    _reservedParams.add("p_p_lifecycle");
474                    _reservedParams.add("p_p_url_type");
475                    _reservedParams.add("p_p_state");
476                    _reservedParams.add("p_p_state_rcv"); // LPS-14144
477                    _reservedParams.add("p_p_mode");
478                    _reservedParams.add("p_p_resource_id");
479                    _reservedParams.add("p_p_cacheability");
480                    _reservedParams.add("p_p_width");
481                    _reservedParams.add("p_p_col_id");
482                    _reservedParams.add("p_p_col_pos");
483                    _reservedParams.add("p_p_col_count");
484                    _reservedParams.add("p_p_static");
485                    _reservedParams.add("p_p_isolated");
486    
487                    // Portal theme
488    
489                    _reservedParams.add("p_t_lifecycle"); // LPS-14383
490    
491                    // Portal virtual layout
492    
493                    _reservedParams.add("p_v_l_s_g_id"); // LPS-23010
494    
495                    // Portal fragment
496    
497                    _reservedParams.add("p_f_id");
498    
499                    // Portal journal article
500    
501                    _reservedParams.add("p_j_a_id"); // LPS-16418
502    
503                    // Miscellaneous
504    
505                    _reservedParams.add("saveLastPath");
506                    _reservedParams.add("scroll");
507                    _reservedParams.add("switchGroup");
508    
509                    _servletContextName =
510                            PortalContextLoaderListener.getPortalServlerContextName();
511    
512                    if (ArrayUtil.isEmpty(PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) ||
513                            ArrayUtil.contains(
514                                    PropsValues.VIRTUAL_HOSTS_VALID_HOSTS, StringPool.STAR)) {
515    
516                            _validPortalDomainCheckDisabled = true;
517                    }
518            }
519    
520            @Override
521            public void addPageDescription(
522                    String description, HttpServletRequest request) {
523    
524                    ListMergeable<String> descriptionListMergeable =
525                            (ListMergeable<String>)request.getAttribute(
526                                    WebKeys.PAGE_DESCRIPTION);
527    
528                    if (descriptionListMergeable == null) {
529                            descriptionListMergeable = new ListMergeable<String>();
530    
531                            request.setAttribute(
532                                    WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
533                    }
534    
535                    descriptionListMergeable.add(description);
536            }
537    
538            @Override
539            public void addPageKeywords(String keywords, HttpServletRequest request) {
540                    ListMergeable<String> keywordsListMergeable =
541                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_KEYWORDS);
542    
543                    if (keywordsListMergeable == null) {
544                            keywordsListMergeable = new ListMergeable<String>();
545    
546                            request.setAttribute(WebKeys.PAGE_KEYWORDS, keywordsListMergeable);
547                    }
548    
549                    String[] keywordsArray = StringUtil.split(keywords);
550    
551                    for (String keyword : keywordsArray) {
552                            if (!keywordsListMergeable.contains(
553                                            StringUtil.toLowerCase(keyword))) {
554    
555                                    keywordsListMergeable.add(StringUtil.toLowerCase(keyword));
556                            }
557                    }
558            }
559    
560            @Override
561            public void addPageSubtitle(String subtitle, HttpServletRequest request) {
562                    ListMergeable<String> subtitleListMergeable =
563                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_SUBTITLE);
564    
565                    if (subtitleListMergeable == null) {
566                            subtitleListMergeable = new ListMergeable<String>();
567    
568                            request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
569                    }
570    
571                    subtitleListMergeable.add(subtitle);
572            }
573    
574            @Override
575            public void addPageTitle(String title, HttpServletRequest request) {
576                    ListMergeable<String> titleListMergeable =
577                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_TITLE);
578    
579                    if (titleListMergeable == null) {
580                            titleListMergeable = new ListMergeable<String>();
581    
582                            request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
583                    }
584    
585                    titleListMergeable.add(title);
586            }
587    
588            @Override
589            public void addPortalPortEventListener(
590                    PortalPortEventListener portalPortEventListener) {
591    
592                    if (!_portalPortEventListeners.contains(portalPortEventListener)) {
593                            _portalPortEventListeners.add(portalPortEventListener);
594                    }
595            }
596    
597            @Override
598            public void addPortalPortProtocolEventListener(
599                    PortalPortProtocolEventListener portalPortProtocolEventListener) {
600    
601                    if (!_portalPortProtocolEventListeners.contains(
602                                    portalPortProtocolEventListener)) {
603    
604                            _portalPortProtocolEventListeners.add(
605                                            portalPortProtocolEventListener);
606                    }
607            }
608    
609            @Override
610            public void addPortletBreadcrumbEntry(
611                    HttpServletRequest request, String title, String url) {
612    
613                    addPortletBreadcrumbEntry(request, title, url, null);
614            }
615    
616            @Override
617            public void addPortletBreadcrumbEntry(
618                    HttpServletRequest request, String title, String url,
619                    Map<String, Object> data) {
620    
621                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
622                            WebKeys.THEME_DISPLAY);
623    
624                    PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
625    
626                    String name = WebKeys.PORTLET_BREADCRUMBS;
627    
628                    if (Validator.isNotNull(portletDisplay.getId()) &&
629                            !portletDisplay.isFocused()) {
630    
631                            name += StringPool.UNDERLINE + portletDisplay.getId();
632                    }
633    
634                    List<BreadcrumbEntry> breadcrumbEntries =
635                            (List<BreadcrumbEntry>)request.getAttribute(name);
636    
637                    if (breadcrumbEntries == null) {
638                            breadcrumbEntries = new ArrayList<BreadcrumbEntry>();
639    
640                            request.setAttribute(name, breadcrumbEntries);
641                    }
642    
643                    BreadcrumbEntry breadcrumbEntry = new BreadcrumbEntry();
644    
645                    breadcrumbEntry.setData(data);
646                    breadcrumbEntry.setTitle(title);
647                    breadcrumbEntry.setURL(url);
648    
649                    breadcrumbEntries.add(breadcrumbEntry);
650            }
651    
652            @Override
653            public void addPortletDefaultResource(
654                            HttpServletRequest request, Portlet portlet)
655                    throws PortalException, SystemException {
656    
657                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
658                            WebKeys.THEME_DISPLAY);
659    
660                    Layout layout = themeDisplay.getLayout();
661    
662                    long groupId = 0;
663    
664                    if (layout.isTypeControlPanel()) {
665                            groupId = themeDisplay.getScopeGroupId();
666                    }
667                    else {
668                            groupId = getScopeGroupId(layout, portlet.getPortletId());
669                    }
670    
671                    addDefaultResource(
672                            themeDisplay.getCompanyId(), groupId, layout, portlet, true);
673                    addDefaultResource(
674                            themeDisplay.getCompanyId(), groupId, layout, portlet, false);
675            }
676    
677            @Override
678            public void addPortletDefaultResource(
679                            long companyId, Layout layout, Portlet portlet)
680                    throws PortalException, SystemException {
681    
682                    addDefaultResource(companyId, layout, portlet, true);
683                    addDefaultResource(companyId, layout, portlet, false);
684            }
685    
686            @Override
687            public String addPreservedParameters(
688                    ThemeDisplay themeDisplay, Layout layout, String url,
689                    boolean doAsUser) {
690    
691                    if (doAsUser) {
692                            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
693                                    url = HttpUtil.setParameter(
694                                            url, "doAsUserId", themeDisplay.getDoAsUserId());
695                            }
696    
697                            if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
698                                    url = HttpUtil.setParameter(
699                                            url, "doAsUserLanguageId",
700                                            themeDisplay.getDoAsUserLanguageId());
701                            }
702                    }
703    
704                    if (layout.isTypeControlPanel()) {
705                            if (themeDisplay.getDoAsGroupId() > 0) {
706                                    url = HttpUtil.setParameter(
707                                            url, "doAsGroupId", themeDisplay.getDoAsGroupId());
708                            }
709    
710                            if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
711                                    url = HttpUtil.setParameter(
712                                            url, "refererPlid", themeDisplay.getRefererPlid());
713                            }
714    
715                            if (Validator.isNotNull(themeDisplay.getControlPanelCategory())) {
716                                    url = HttpUtil.setParameter(
717                                            url, "controlPanelCategory",
718                                            themeDisplay.getControlPanelCategory());
719                            }
720                    }
721    
722                    return url;
723            }
724    
725            @Override
726            public String addPreservedParameters(
727                    ThemeDisplay themeDisplay, String url) {
728    
729                    return addPreservedParameters(
730                            themeDisplay, themeDisplay.getLayout(), url, true);
731            }
732    
733            @Override
734            public void addUserLocaleOptionsMessage(HttpServletRequest request) {
735                    boolean ignoreUserLocaleOptions = GetterUtil.getBoolean(
736                            SessionClicks.get(
737                                    request.getSession(), "ignoreUserLocaleOptions",
738                                    Boolean.FALSE.toString()));
739    
740                    if (ignoreUserLocaleOptions) {
741                            return;
742                    }
743    
744                    boolean showUserLocaleOptionsMessage = ParamUtil.getBoolean(
745                            request, "showUserLocaleOptionsMessage", true);
746    
747                    if (!showUserLocaleOptionsMessage) {
748                            return;
749                    }
750    
751                    PortalMessages.add(request, PortalMessages.KEY_ANIMATION, false);
752                    PortalMessages.add(
753                            request, PortalMessages.KEY_JSP_PATH,
754                            "/html/common/themes/user_locale_options.jsp");
755                    PortalMessages.add(request, PortalMessages.KEY_TIMEOUT, -1);
756            }
757    
758            @Override
759            public void clearRequestParameters(RenderRequest renderRequest) {
760                    RenderRequestImpl renderRequestImpl = (RenderRequestImpl)renderRequest;
761    
762                    if (renderRequestImpl.isTriggeredByActionURL()) {
763                            Map<String, String[]> renderParameters =
764                                    renderRequestImpl.getRenderParameters();
765    
766                            renderParameters.clear();
767                    }
768            }
769    
770            @Override
771            public void copyRequestParameters(
772                    ActionRequest actionRequest, ActionResponse actionResponse) {
773    
774                    if (actionResponse instanceof StateAwareResponseImpl) {
775                            StateAwareResponseImpl stateAwareResponseImpl =
776                                    (StateAwareResponseImpl)actionResponse;
777    
778                            if (stateAwareResponseImpl.getRedirectLocation() != null) {
779                                    if (_log.isDebugEnabled()) {
780                                            _log.debug(
781                                                    "Cannot copy parameters on a redirected " +
782                                                            "StateAwareResponseImpl");
783                                    }
784    
785                                    return;
786                            }
787                    }
788    
789                    ActionResponseImpl actionResponseImpl =
790                            (ActionResponseImpl)actionResponse;
791    
792                    Map<String, String[]> renderParameters =
793                            actionResponseImpl.getRenderParameterMap();
794    
795                    actionResponse.setRenderParameter("p_p_lifecycle", "1");
796    
797                    Enumeration<String> enu = actionRequest.getParameterNames();
798    
799                    while (enu.hasMoreElements()) {
800                            String param = enu.nextElement();
801                            String[] values = actionRequest.getParameterValues(param);
802    
803                            if (renderParameters.get(
804                                            actionResponseImpl.getNamespace() + param) == null) {
805    
806                                    actionResponse.setRenderParameter(param, values);
807                            }
808                    }
809            }
810    
811            @Override
812            public String escapeRedirect(String url) {
813                    if (Validator.isNull(url)) {
814                            return url;
815                    }
816    
817                    String domain = HttpUtil.getDomain(url);
818    
819                    if (domain.isEmpty()) {
820                            return url;
821                    }
822    
823                    int pos = domain.indexOf(CharPool.COLON);
824    
825                    if (pos != -1) {
826                            domain = domain.substring(0, pos);
827                    }
828    
829                    if (!_validPortalDomainCheckDisabled && isValidPortalDomain(domain)) {
830                            return url;
831                    }
832    
833                    try {
834                            String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
835    
836                            if (securityMode.equals("domain")) {
837                                    String[] allowedDomains =
838                                            PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
839    
840                                    if ((allowedDomains.length > 0) &&
841                                            !ArrayUtil.contains(allowedDomains, domain)) {
842    
843                                            if (_log.isWarnEnabled()) {
844                                                    _log.warn("Redirect URL " + url + " is not allowed");
845                                            }
846    
847                                            url = null;
848                                    }
849                            }
850                            else if (securityMode.equals("ip")) {
851                                    String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
852    
853                                    if (allowedIps.length == 0) {
854                                            return url;
855                                    }
856    
857                                    InetAddress inetAddress = InetAddress.getByName(domain);
858    
859                                    String hostAddress = inetAddress.getHostAddress();
860    
861                                    boolean serverIpIsHostAddress = _computerAddresses.contains(
862                                            hostAddress);
863    
864                                    for (String ip : allowedIps) {
865                                            if ((serverIpIsHostAddress && ip.equals("SERVER_IP")) ||
866                                                    ip.equals(hostAddress)) {
867    
868                                                    return url;
869                                            }
870                                    }
871    
872                                    if (_log.isWarnEnabled()) {
873                                            _log.warn("Redirect URL " + url + " is not allowed");
874                                    }
875    
876                                    url = null;
877                            }
878                    }
879                    catch (UnknownHostException uhe) {
880                            if (_log.isDebugEnabled()) {
881                                    _log.debug("Unable to determine IP for redirect URL " + url);
882                            }
883    
884                            url = null;
885                    }
886    
887                    return url;
888            }
889    
890            @Override
891            public String generateRandomKey(HttpServletRequest request, String input) {
892                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
893                            WebKeys.THEME_DISPLAY);
894    
895                    if (themeDisplay.isAjax() || themeDisplay.isIsolated() ||
896                            themeDisplay.isLifecycleResource() ||
897                            themeDisplay.isStateExclusive()) {
898    
899                            return StringUtil.randomId();
900                    }
901                    else {
902                            StringBundler sb = new StringBundler(5);
903    
904                            sb.append(DeterminateKeyGenerator.generate(input));
905                            sb.append(StringPool.UNDERLINE);
906                            sb.append(request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID));
907                            sb.append(StringPool.UNDERLINE);
908                            sb.append(request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS));
909    
910                            return JS.getSafeName(sb.toString());
911                    }
912            }
913    
914            @Override
915            public String getAbsoluteURL(HttpServletRequest request, String url) {
916                    String portalURL = getPortalURL(request);
917    
918                    if (url.charAt(0) == CharPool.SLASH) {
919                            if (Validator.isNotNull(portalURL)) {
920                                    url = portalURL.concat(url);
921                            }
922                    }
923    
924                    if (!CookieKeys.hasSessionId(request) && url.startsWith(portalURL)) {
925                            url = getURLWithSessionId(url, request.getSession().getId());
926                    }
927    
928                    return url;
929            }
930    
931            @Override
932            public LayoutQueryStringComposite getActualLayoutQueryStringComposite(
933                            long groupId, boolean privateLayout, String friendlyURL,
934                            Map<String, String[]> params, Map<String, Object> requestContext)
935                    throws PortalException, SystemException {
936    
937                    Layout layout = null;
938                    String layoutQueryStringCompositeFriendlyURL = friendlyURL;
939                    String queryString = StringPool.BLANK;
940    
941                    if (Validator.isNull(friendlyURL)) {
942    
943                            // We need to ensure that virtual layouts are merged
944    
945                            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
946                                    groupId, privateLayout,
947                                    LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
948    
949                            if (!layouts.isEmpty()) {
950                                    layout = layouts.get(0);
951                            }
952                            else {
953                                    throw new NoSuchLayoutException(
954                                            "{groupId=" + groupId + ", privateLayout=" + privateLayout +
955                                                    "}");
956                            }
957                    }
958                    else {
959                            LayoutQueryStringComposite layoutQueryStringComposite =
960                                    getPortletFriendlyURLMapperLayoutQueryStringComposite(
961                                            groupId, privateLayout, friendlyURL, params,
962                                            requestContext);
963    
964                            layout = layoutQueryStringComposite.getLayout();
965                            layoutQueryStringCompositeFriendlyURL =
966                                    layoutQueryStringComposite.getFriendlyURL();
967                            queryString = layoutQueryStringComposite.getQueryString();
968                    }
969    
970                    return new LayoutQueryStringComposite(
971                            layout, layoutQueryStringCompositeFriendlyURL, queryString);
972            }
973    
974            @Override
975            public String getActualURL(
976                            long groupId, boolean privateLayout, String mainPath,
977                            String friendlyURL, Map<String, String[]> params,
978                            Map<String, Object> requestContext)
979                    throws PortalException, SystemException {
980    
981                    String actualURL = null;
982    
983                    if (friendlyURL != null) {
984                            if (friendlyURL.startsWith(
985                                            JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
986    
987                                    try {
988                                            actualURL = getJournalArticleActualURL(
989                                                    groupId, privateLayout, mainPath, friendlyURL, params,
990                                                    requestContext);
991                                    }
992                                    catch (Exception e) {
993                                            throw new NoSuchLayoutException(e);
994                                    }
995                            }
996                            else if (friendlyURL.startsWith(
997                                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
998    
999                                    try {
1000                                            actualURL = getVirtualLayoutActualURL(
1001                                                    groupId, privateLayout, mainPath, friendlyURL, params,
1002                                                    requestContext);
1003                                    }
1004                                    catch (Exception e) {
1005                                            throw new NoSuchLayoutException(e);
1006                                    }
1007                            }
1008                    }
1009    
1010                    if (actualURL == null) {
1011                            actualURL = getLayoutActualURL(
1012                                    groupId, privateLayout, mainPath, friendlyURL, params,
1013                                    requestContext);
1014                    }
1015    
1016                    return actualURL;
1017            }
1018    
1019            /**
1020             * @deprecated As of 6.2.0, replaced by {@link
1021             *             LanguageUtil#getAvailableLocales}
1022             */
1023            @Override
1024            public Locale[] getAlternateLocales(HttpServletRequest request) {
1025                    return LanguageUtil.getAvailableLocales();
1026            }
1027    
1028            @Override
1029            public String getAlternateURL(
1030                            String canonicalURL, ThemeDisplay themeDisplay, Locale locale,
1031                            Layout layout)
1032                    throws PortalException, SystemException {
1033    
1034                    String virtualHostname = getVirtualHostname(
1035                            themeDisplay.getLayoutSet());
1036    
1037                    if (Validator.isNull(virtualHostname)) {
1038                            Company company = themeDisplay.getCompany();
1039    
1040                            virtualHostname = company.getVirtualHostname();
1041                    }
1042    
1043                    String portalDomain = themeDisplay.getPortalDomain();
1044    
1045                    if (!Validator.isBlank(portalDomain) &&
1046                            !StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) &&
1047                            StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
1048    
1049                            virtualHostname = portalDomain;
1050                    }
1051    
1052                    String i18nPath = buildI18NPath(locale);
1053    
1054                    if (Validator.isNull(virtualHostname)) {
1055                            return canonicalURL.replaceFirst(
1056                                    _PUBLIC_GROUP_SERVLET_MAPPING,
1057                                    i18nPath.concat(_PUBLIC_GROUP_SERVLET_MAPPING));
1058                    }
1059    
1060                    // www.liferay.com:8080/ctx/page to www.liferay.com:8080/ctx/es/page
1061    
1062                    int pos = canonicalURL.indexOf(virtualHostname);
1063    
1064                    if (pos > 0) {
1065                            pos = canonicalURL.indexOf(
1066                                    CharPool.SLASH, pos + virtualHostname.length());
1067    
1068                            if (Validator.isNotNull(_pathContext)) {
1069                                    pos = canonicalURL.indexOf(
1070                                            CharPool.SLASH, pos + _pathContext.length());
1071                            }
1072    
1073                            if ((pos > 0) && (pos < canonicalURL.length())) {
1074                                    boolean replaceFriendlyURL = true;
1075    
1076                                    String currentURL = canonicalURL.substring(pos);
1077    
1078                                    int[] friendlyURLIndex = getGroupFriendlyURLIndex(currentURL);
1079    
1080                                    if (friendlyURLIndex != null) {
1081                                            int y = friendlyURLIndex[1];
1082    
1083                                            currentURL = currentURL.substring(y);
1084    
1085                                            if (currentURL.equals(StringPool.SLASH)) {
1086                                                    replaceFriendlyURL = false;
1087                                            }
1088                                    }
1089    
1090                                    if (replaceFriendlyURL) {
1091                                            String canonicalURLPrefix = canonicalURL.substring(0, pos);
1092    
1093                                            String canonicalURLSuffix = canonicalURL.substring(pos);
1094    
1095                                            canonicalURLSuffix = StringUtil.replaceFirst(
1096                                                    canonicalURLSuffix, layout.getFriendlyURL(),
1097                                                    layout.getFriendlyURL(locale));
1098    
1099                                            canonicalURL = canonicalURLPrefix.concat(
1100                                                    canonicalURLSuffix);
1101                                    }
1102    
1103                                    Locale siteDefaultLocale = getSiteDefaultLocale(
1104                                            layout.getGroupId());
1105    
1106                                    if (siteDefaultLocale.equals(locale)) {
1107                                            return canonicalURL;
1108                                    }
1109    
1110                                    return canonicalURL.substring(0, pos).concat(
1111                                            i18nPath).concat(canonicalURL.substring(pos));
1112                            }
1113                    }
1114    
1115                    return canonicalURL.concat(i18nPath);
1116            }
1117    
1118            /**
1119             * @deprecated As of 6.2.0, replaced by {@link
1120             *             AuthTokenWhitelistUtil#getPortletCSRFWhitelistActions}
1121             */
1122            @Override
1123            public Set<String> getAuthTokenIgnoreActions() {
1124                    return AuthTokenWhitelistUtil.getPortletCSRFWhitelistActions();
1125            }
1126    
1127            /**
1128             * @deprecated As of 6.2.0, replaced by {@link
1129             *             AuthTokenWhitelistUtil#getPortletCSRFWhitelist}
1130             */
1131            @Override
1132            public Set<String> getAuthTokenIgnorePortlets() {
1133                    return AuthTokenWhitelistUtil.getPortletCSRFWhitelist();
1134            }
1135    
1136            @Override
1137            public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
1138                    throws PortalException, SystemException {
1139    
1140                    String modelName = resourcePermission.getName();
1141                    String primKey = resourcePermission.getPrimKey();
1142    
1143                    return getBaseModel(modelName, primKey);
1144            }
1145    
1146            @Override
1147            public BaseModel<?> getBaseModel(String modelName, String primKey)
1148                    throws PortalException, SystemException {
1149    
1150                    if (!modelName.contains(".model.")) {
1151                            return null;
1152                    }
1153    
1154                    String[] parts = StringUtil.split(modelName, CharPool.PERIOD);
1155    
1156                    if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
1157                            return null;
1158                    }
1159    
1160                    parts[parts.length - 2] = "service";
1161    
1162                    String serviceName =
1163                            StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
1164                    String methodName = "get" + parts[parts.length - 1];
1165    
1166                    Method method = null;
1167    
1168                    try {
1169                            Class<?> serviceUtil = Class.forName(serviceName);
1170    
1171                            if (Validator.isNumber(primKey)) {
1172                                    method = serviceUtil.getMethod(
1173                                            methodName, new Class[] {Long.TYPE});
1174    
1175                                    return (BaseModel<?>)method.invoke(null, new Long(primKey));
1176                            }
1177    
1178                            method = serviceUtil.getMethod(
1179                                    methodName, new Class[] {String.class});
1180    
1181                            return (BaseModel<?>)method.invoke(null, primKey);
1182                    }
1183                    catch (Exception e) {
1184                            Throwable cause = e.getCause();
1185    
1186                            if (cause instanceof PortalException) {
1187                                    throw (PortalException)cause;
1188                            }
1189                            else if (cause instanceof SystemException) {
1190                                    throw (SystemException)cause;
1191                            }
1192                            else {
1193                                    throw new SystemException(cause);
1194                            }
1195                    }
1196            }
1197    
1198            @Override
1199            public long getBasicAuthUserId(HttpServletRequest request)
1200                    throws PortalException, SystemException {
1201    
1202                    long companyId = PortalInstances.getCompanyId(request);
1203    
1204                    return getBasicAuthUserId(request, companyId);
1205            }
1206    
1207            @Override
1208            public long getBasicAuthUserId(HttpServletRequest request, long companyId)
1209                    throws PortalException, SystemException {
1210    
1211                    long userId = 0;
1212    
1213                    String authorizationHeader = request.getHeader(
1214                            HttpHeaders.AUTHORIZATION);
1215    
1216                    if (Validator.isNull(authorizationHeader)) {
1217                            return userId;
1218                    }
1219    
1220                    String[] authorizationArray = authorizationHeader.split("\\s+");
1221    
1222                    String authorization = authorizationArray[0];
1223                    String credentials = new String(Base64.decode(authorizationArray[1]));
1224    
1225                    if (!StringUtil.equalsIgnoreCase(
1226                                    authorization, HttpServletRequest.BASIC_AUTH)) {
1227    
1228                            return userId;
1229                    }
1230    
1231                    String[] loginAndPassword = StringUtil.split(
1232                            credentials, CharPool.COLON);
1233    
1234                    String login = HttpUtil.decodeURL(loginAndPassword[0].trim());
1235    
1236                    String password = null;
1237    
1238                    if (loginAndPassword.length > 1) {
1239                            password = loginAndPassword[1].trim();
1240                    }
1241    
1242                    // Strip @uid and @sn for backwards compatibility
1243    
1244                    if (login.endsWith("@uid")) {
1245                            int pos = login.indexOf("@uid");
1246    
1247                            login = login.substring(0, pos);
1248                    }
1249                    else if (login.endsWith("@sn")) {
1250                            int pos = login.indexOf("@sn");
1251    
1252                            login = login.substring(0, pos);
1253                    }
1254    
1255                    try {
1256                            userId = LoginUtil.getAuthenticatedUserId(
1257                                    request, login, password, null);
1258                    }
1259                    catch (AuthException ae) {
1260                    }
1261    
1262                    return userId;
1263            }
1264    
1265            @Override
1266            public String getCanonicalURL(
1267                            String completeURL, ThemeDisplay themeDisplay, Layout layout)
1268                    throws PortalException, SystemException {
1269    
1270                    return getCanonicalURL(completeURL, themeDisplay, layout, false);
1271            }
1272    
1273            @Override
1274            public String getCanonicalURL(
1275                            String completeURL, ThemeDisplay themeDisplay, Layout layout,
1276                            boolean forceLayoutFriendlyURL)
1277                    throws PortalException, SystemException {
1278    
1279                    String groupFriendlyURL = StringPool.BLANK;
1280                    String parametersURL = StringPool.BLANK;
1281    
1282                    if (Validator.isNotNull(completeURL)) {
1283                            completeURL = removeRedirectParameter(completeURL);
1284    
1285                            int pos = completeURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
1286    
1287                            if (pos == -1) {
1288                                    pos = completeURL.indexOf(StringPool.QUESTION);
1289                            }
1290    
1291                            groupFriendlyURL = completeURL;
1292    
1293                            if (pos != -1) {
1294                                    groupFriendlyURL = completeURL.substring(0, pos);
1295                                    parametersURL = completeURL.substring(pos);
1296                            }
1297                    }
1298    
1299                    if (layout == null) {
1300                            layout = themeDisplay.getLayout();
1301                    }
1302    
1303                    String canonicalLayoutFriendlyURL = StringPool.BLANK;
1304    
1305                    String layoutFriendlyURL = layout.getFriendlyURL(
1306                            themeDisplay.getLocale());
1307    
1308                    String defaultLayoutFriendlyURL = layout.getFriendlyURL(
1309                            getSiteDefaultLocale(layout.getGroupId()));
1310    
1311                    if ((groupFriendlyURL.contains(layoutFriendlyURL) ||
1312                             groupFriendlyURL.contains(
1313                                    StringPool.SLASH + layout.getLayoutId())) &&
1314                            (!layout.isFirstParent() || Validator.isNotNull(parametersURL))) {
1315    
1316                            canonicalLayoutFriendlyURL = defaultLayoutFriendlyURL;
1317                    }
1318                    else if (forceLayoutFriendlyURL) {
1319                            canonicalLayoutFriendlyURL = defaultLayoutFriendlyURL;
1320                    }
1321    
1322                    groupFriendlyURL = getGroupFriendlyURL(
1323                            layout.getLayoutSet(), themeDisplay, true);
1324    
1325                    return groupFriendlyURL.concat(canonicalLayoutFriendlyURL).concat(
1326                            parametersURL);
1327            }
1328    
1329            /**
1330             * @deprecated As of 6.1.0, replaced by {@link #getCDNHost(boolean)}
1331             */
1332            @Override
1333            public String getCDNHost() {
1334                    long companyId = CompanyThreadLocal.getCompanyId();
1335    
1336                    return getCDNHostHttp(companyId);
1337            }
1338    
1339            @Override
1340            public String getCDNHost(boolean secure) {
1341                    long companyId = CompanyThreadLocal.getCompanyId();
1342    
1343                    if (secure) {
1344                            return getCDNHostHttps(companyId);
1345                    }
1346                    else {
1347                            return getCDNHostHttp(companyId);
1348                    }
1349            }
1350    
1351            @Override
1352            public String getCDNHost(HttpServletRequest request)
1353                    throws PortalException, SystemException {
1354    
1355                    boolean cdnEnabled = ParamUtil.getBoolean(request, "cdn_enabled", true);
1356    
1357                    if (!cdnEnabled) {
1358                            return StringPool.BLANK;
1359                    }
1360    
1361                    String cdnHost = null;
1362    
1363                    Company company = getCompany(request);
1364    
1365                    if (request.isSecure()) {
1366                            cdnHost = getCDNHostHttps(company.getCompanyId());
1367                    }
1368                    else {
1369                            cdnHost = getCDNHostHttp(company.getCompanyId());
1370                    }
1371    
1372                    if (Validator.isUrl(cdnHost)) {
1373                            return cdnHost;
1374                    }
1375    
1376                    return StringPool.BLANK;
1377            }
1378    
1379            @Override
1380            public String getCDNHostHttp(long companyId) {
1381                    String cdnHostHttp = _cdnHostHttpMap.get(companyId);
1382    
1383                    if (cdnHostHttp != null) {
1384                            return cdnHostHttp;
1385                    }
1386    
1387                    try {
1388                            cdnHostHttp = PrefsPropsUtil.getString(
1389                                    companyId, PropsKeys.CDN_HOST_HTTP, PropsValues.CDN_HOST_HTTP);
1390                    }
1391                    catch (Exception e) {
1392                    }
1393    
1394                    if ((cdnHostHttp == null) || cdnHostHttp.startsWith("${") ||
1395                            !Validator.isUrl(cdnHostHttp)) {
1396    
1397                            cdnHostHttp = StringPool.BLANK;
1398                    }
1399    
1400                    _cdnHostHttpMap.put(companyId, cdnHostHttp);
1401    
1402                    return cdnHostHttp;
1403            }
1404    
1405            @Override
1406            public String getCDNHostHttps(long companyId) {
1407                    String cdnHostHttps = _cdnHostHttpsMap.get(companyId);
1408    
1409                    if (cdnHostHttps != null) {
1410                            return cdnHostHttps;
1411                    }
1412    
1413                    try {
1414                            cdnHostHttps = PrefsPropsUtil.getString(
1415                                    companyId, PropsKeys.CDN_HOST_HTTPS,
1416                                    PropsValues.CDN_HOST_HTTPS);
1417                    }
1418                    catch (SystemException se) {
1419                    }
1420    
1421                    if ((cdnHostHttps == null) || cdnHostHttps.startsWith("${") ||
1422                            !Validator.isUrl(cdnHostHttps)) {
1423    
1424                            cdnHostHttps = StringPool.BLANK;
1425                    }
1426    
1427                    _cdnHostHttpsMap.put(companyId, cdnHostHttps);
1428    
1429                    return cdnHostHttps;
1430            }
1431    
1432            @Override
1433            public String getClassName(long classNameId) {
1434                    try {
1435                            ClassName className = ClassNameLocalServiceUtil.getClassName(
1436                                    classNameId);
1437    
1438                            return className.getValue();
1439                    }
1440                    catch (Exception e) {
1441                            throw new RuntimeException(
1442                                    "Unable to get class name from id " + classNameId);
1443                    }
1444            }
1445    
1446            @Override
1447            public long getClassNameId(Class<?> clazz) {
1448                    return ClassNameLocalServiceUtil.getClassNameId(clazz);
1449            }
1450    
1451            @Override
1452            public long getClassNameId(String value) {
1453                    return ClassNameLocalServiceUtil.getClassNameId(value);
1454            }
1455    
1456            @Override
1457            public String getClassNamePortletId(String className) {
1458                    String portletId = StringPool.BLANK;
1459    
1460                    if (className.startsWith("com.liferay.portlet.blogs")) {
1461                            portletId = PortletKeys.BLOGS;
1462                    }
1463                    else if (className.startsWith("com.liferay.portlet.bookmarks")) {
1464                            portletId = PortletKeys.BOOKMARKS;
1465                    }
1466                    else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
1467                            portletId = PortletKeys.DOCUMENT_LIBRARY;
1468                    }
1469                    else if (className.startsWith("com.liferay.portlet.imagegallery")) {
1470                            portletId = PortletKeys.MEDIA_GALLERY_DISPLAY;
1471                    }
1472                    else if (className.startsWith("com.liferay.portlet.journal")) {
1473                            portletId = PortletKeys.JOURNAL;
1474                    }
1475                    else if (className.startsWith("com.liferay.portlet.messageboards")) {
1476                            portletId = PortletKeys.MESSAGE_BOARDS;
1477                    }
1478                    else if (className.startsWith("com.liferay.portlet.wiki")) {
1479                            portletId = PortletKeys.WIKI;
1480                    }
1481    
1482                    return portletId;
1483            }
1484    
1485            @Override
1486            public Company getCompany(HttpServletRequest request)
1487                    throws PortalException, SystemException {
1488    
1489                    long companyId = getCompanyId(request);
1490    
1491                    if (companyId <= 0) {
1492                            return null;
1493                    }
1494    
1495                    Company company = (Company)request.getAttribute(WebKeys.COMPANY);
1496    
1497                    if (company == null) {
1498    
1499                            // LEP-5994
1500    
1501                            company = CompanyLocalServiceUtil.fetchCompanyById(companyId);
1502    
1503                            if (company == null) {
1504                                    company = CompanyLocalServiceUtil.getCompanyById(
1505                                            PortalInstances.getDefaultCompanyId());
1506                            }
1507    
1508                            request.setAttribute(WebKeys.COMPANY, company);
1509                    }
1510    
1511                    return company;
1512            }
1513    
1514            @Override
1515            public Company getCompany(PortletRequest portletRequest)
1516                    throws PortalException, SystemException {
1517    
1518                    return getCompany(getHttpServletRequest(portletRequest));
1519            }
1520    
1521            @Override
1522            public long getCompanyId(HttpServletRequest request) {
1523                    return PortalInstances.getCompanyId(request);
1524            }
1525    
1526            @Override
1527            public long getCompanyId(PortletRequest portletRequest) {
1528                    return getCompanyId(getHttpServletRequest(portletRequest));
1529            }
1530    
1531            @Override
1532            public long[] getCompanyIds() {
1533                    return PortalInstances.getCompanyIds();
1534            }
1535    
1536            /**
1537             * @deprecated As of 7.0.0, replaced by {@link #getComputerAddresses()}
1538             */
1539            @Deprecated
1540            @Override
1541            public String getComputerAddress() {
1542                    return _computerAddress;
1543            }
1544    
1545            @Override
1546            public Set<String> getComputerAddresses() {
1547                    return _computerAddresses;
1548            }
1549    
1550            @Override
1551            public String getComputerName() {
1552                    return _computerName;
1553            }
1554    
1555            @Override
1556            public Map<String, List<Portlet>> getControlPanelCategoriesMap(
1557                            HttpServletRequest request)
1558                    throws SystemException {
1559    
1560                    return getCategoriesMap(
1561                            request, WebKeys.CONTROL_PANEL_CATEGORIES_MAP,
1562                            PortletCategoryKeys.ALL);
1563            }
1564    
1565            @Override
1566            public String getControlPanelCategory(
1567                            String portletId, ThemeDisplay themeDisplay)
1568                    throws SystemException {
1569    
1570                    for (String category : PortletCategoryKeys.ALL) {
1571                            List<Portlet> portlets = getControlPanelPortlets(
1572                                    category, themeDisplay);
1573    
1574                            for (Portlet portlet : portlets) {
1575                                    if (portlet.getPortletId().equals(portletId)) {
1576                                            return category;
1577                                    }
1578                            }
1579                    }
1580    
1581                    return StringPool.BLANK;
1582            }
1583    
1584            @Override
1585            public String getControlPanelFullURL(
1586                            long scopeGroupId, String ppid, Map<String, String[]> params)
1587                    throws PortalException, SystemException {
1588    
1589                    StringBundler sb = new StringBundler(6);
1590    
1591                    Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1592    
1593                    Company company = CompanyLocalServiceUtil.getCompany(
1594                            group.getCompanyId());
1595    
1596                    sb.append(
1597                            getPortalURL(
1598                                    company.getVirtualHostname(), getPortalPort(false), false));
1599                    sb.append(getPathFriendlyURLPrivateGroup());
1600                    sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1601                    sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1602    
1603                    if (params != null) {
1604                            params = new HashMap<String, String[]>(params);
1605                    }
1606                    else {
1607                            params = new HashMap<String, String[]>();
1608                    }
1609    
1610                    params.put("p_p_id", new String[] {ppid});
1611                    params.put("p_p_lifecycle", new String[] {"0"});
1612                    params.put(
1613                            "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1614                    params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1615                    params.put("doAsGroupId", new String[] {String.valueOf(scopeGroupId)});
1616                    params.put(
1617                            "controlPanelCategory",
1618                            new String[] {PortletCategoryKeys.CURRENT_SITE});
1619    
1620                    sb.append(HttpUtil.parameterMapToString(params, true));
1621    
1622                    return sb.toString();
1623            }
1624    
1625            @Override
1626            public long getControlPanelPlid(long companyId)
1627                    throws PortalException, SystemException {
1628    
1629                    Group controlPanelGroup = GroupLocalServiceUtil.getGroup(
1630                            companyId, GroupConstants.CONTROL_PANEL);
1631    
1632                    return LayoutLocalServiceUtil.getDefaultPlid(
1633                            controlPanelGroup.getGroupId(), true);
1634            }
1635    
1636            @Override
1637            public long getControlPanelPlid(PortletRequest portletRequest)
1638                    throws PortalException, SystemException {
1639    
1640                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1641                            WebKeys.THEME_DISPLAY);
1642    
1643                    return getControlPanelPlid(themeDisplay.getCompanyId());
1644            }
1645    
1646            @Override
1647            public Set<Portlet> getControlPanelPortlets(long companyId, String category)
1648                    throws SystemException {
1649    
1650                    Set<Portlet> portletsSet = new TreeSet<Portlet>(
1651                            new PortletControlPanelWeightComparator());
1652    
1653                    if (Validator.isNull(category)) {
1654                            return portletsSet;
1655                    }
1656    
1657                    List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1658                            companyId);
1659    
1660                    for (Portlet portlet : portletsList) {
1661                            String portletCategory = portlet.getControlPanelEntryCategory();
1662    
1663                            if (category.equals(portletCategory) ||
1664                                    (category.endsWith(StringPool.PERIOD) &&
1665                                     StringUtil.startsWith(portletCategory, category))) {
1666    
1667                                    portletsSet.add(portlet);
1668                            }
1669                    }
1670    
1671                    return portletsSet;
1672            }
1673    
1674            @Override
1675            public List<Portlet> getControlPanelPortlets(
1676                            String category, ThemeDisplay themeDisplay)
1677                    throws SystemException {
1678    
1679                    Set<Portlet> portlets = getControlPanelPortlets(
1680                            themeDisplay.getCompanyId(), category);
1681    
1682                    return filterControlPanelPortlets(portlets, themeDisplay);
1683            }
1684    
1685            @Override
1686            public PortletURL getControlPanelPortletURL(
1687                    HttpServletRequest request, String portletId, long referrerPlid,
1688                    String lifecycle) {
1689    
1690                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1691                            WebKeys.THEME_DISPLAY);
1692    
1693                    long plid = 0;
1694    
1695                    try {
1696                            plid = getControlPanelPlid(themeDisplay.getCompanyId());
1697                    }
1698                    catch (Exception e) {
1699                            _log.error("Unable to determine control panel layout id", e);
1700                    }
1701    
1702                    LiferayPortletURL liferayPortletURL = PortletURLFactoryUtil.create(
1703                            request, portletId, plid, lifecycle);
1704    
1705                    liferayPortletURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
1706                    liferayPortletURL.setRefererPlid(themeDisplay.getPlid());
1707    
1708                    return liferayPortletURL;
1709            }
1710    
1711            @Override
1712            public PortletURL getControlPanelPortletURL(
1713                    PortletRequest portletRequest, String portletId, long referrerPlid,
1714                    String lifecycle) {
1715    
1716                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1717                            WebKeys.THEME_DISPLAY);
1718    
1719                    long plid = 0;
1720    
1721                    try {
1722                            plid = getControlPanelPlid(themeDisplay.getCompanyId());
1723                    }
1724                    catch (Exception e) {
1725                            _log.error("Unable to determine control panel layout id", e);
1726                    }
1727    
1728                    LiferayPortletURL liferayPortletURL = PortletURLFactoryUtil.create(
1729                            portletRequest, portletId, plid, lifecycle);
1730    
1731                    liferayPortletURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
1732                    liferayPortletURL.setRefererPlid(themeDisplay.getPlid());
1733    
1734                    return liferayPortletURL;
1735            }
1736    
1737            @Override
1738            public String getCreateAccountURL(
1739                            HttpServletRequest request, ThemeDisplay themeDisplay)
1740                    throws Exception {
1741    
1742                    if (Validator.isNull(PropsValues.COMPANY_SECURITY_STRANGERS_URL)) {
1743                            PortletURL createAccountURL = PortletURLFactoryUtil.create(
1744                                    request, PortletKeys.LOGIN, themeDisplay.getPlid(),
1745                                    PortletRequest.RENDER_PHASE);
1746    
1747                            createAccountURL.setParameter(
1748                                    "saveLastPath", Boolean.FALSE.toString());
1749                            createAccountURL.setParameter(
1750                                    "struts_action", "/login/create_account");
1751                            createAccountURL.setPortletMode(PortletMode.VIEW);
1752                            createAccountURL.setWindowState(WindowState.MAXIMIZED);
1753    
1754                            if (!PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS) {
1755                                    return createAccountURL.toString();
1756                            }
1757    
1758                            String portalURL = getPortalURL(request);
1759                            String portalURLSecure = getPortalURL(request, true);
1760    
1761                            return StringUtil.replaceFirst(
1762                                    createAccountURL.toString(), portalURL, portalURLSecure);
1763                    }
1764    
1765                    try {
1766                            Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1767                                    themeDisplay.getScopeGroupId(), false,
1768                                    PropsValues.COMPANY_SECURITY_STRANGERS_URL);
1769    
1770                            return getLayoutURL(layout, themeDisplay);
1771                    }
1772                    catch (NoSuchLayoutException nsle) {
1773                    }
1774    
1775                    return StringPool.BLANK;
1776            }
1777    
1778            @Override
1779            public String getCurrentCompleteURL(HttpServletRequest request) {
1780                    String currentCompleteURL = (String)request.getAttribute(
1781                            WebKeys.CURRENT_COMPLETE_URL);
1782    
1783                    if (currentCompleteURL == null) {
1784                            currentCompleteURL = HttpUtil.getCompleteURL(request);
1785    
1786                            request.setAttribute(
1787                                    WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1788                    }
1789    
1790                    return currentCompleteURL;
1791            }
1792    
1793            @Override
1794            public String getCurrentURL(HttpServletRequest request) {
1795                    String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1796    
1797                    if (currentURL != null) {
1798                            return currentURL;
1799                    }
1800    
1801                    currentURL = ParamUtil.getString(request, "currentURL");
1802    
1803                    if (Validator.isNull(currentURL)) {
1804                            currentURL = HttpUtil.getCompleteURL(request);
1805    
1806                            if (Validator.isNotNull(currentURL) &&
1807                                    !currentURL.contains(_J_SECURITY_CHECK)) {
1808    
1809                                    currentURL = currentURL.substring(
1810                                            currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1811                                                    Http.PROTOCOL_DELIMITER.length());
1812    
1813                                    currentURL = currentURL.substring(
1814                                            currentURL.indexOf(CharPool.SLASH));
1815                            }
1816    
1817                            if (Validator.isNotNull(currentURL) &&
1818                                    FacebookUtil.isFacebook(currentURL)) {
1819    
1820                                    String[] facebookData = FacebookUtil.getFacebookData(request);
1821    
1822                                    if (facebookData != null) {
1823                                            currentURL =
1824                                                    FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1825                                                            facebookData[2];
1826                                    }
1827                            }
1828                    }
1829    
1830                    if (Validator.isNull(currentURL)) {
1831                            currentURL = getPathMain();
1832                    }
1833    
1834                    request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1835    
1836                    return currentURL;
1837            }
1838    
1839            @Override
1840            public String getCurrentURL(PortletRequest portletRequest) {
1841                    return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1842            }
1843    
1844            @Override
1845            public String getCustomSQLFunctionIsNotNull() {
1846                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1847            }
1848    
1849            @Override
1850            public String getCustomSQLFunctionIsNull() {
1851                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1852            }
1853    
1854            @Override
1855            public Date getDate(int month, int day, int year) {
1856                    try {
1857                            return getDate(month, day, year, null);
1858                    }
1859                    catch (PortalException pe) {
1860                            throw new RuntimeException();
1861                    }
1862            }
1863    
1864            @Override
1865            public Date getDate(
1866                            int month, int day, int year,
1867                            Class<? extends PortalException> clazz)
1868                    throws PortalException {
1869    
1870                    return getDate(month, day, year, null, clazz);
1871            }
1872    
1873            @Override
1874            public Date getDate(
1875                            int month, int day, int year, int hour, int min,
1876                            Class<? extends PortalException> clazz)
1877                    throws PortalException {
1878    
1879                    return getDate(month, day, year, hour, min, null, clazz);
1880            }
1881    
1882            @Override
1883            public Date getDate(
1884                            int month, int day, int year, int hour, int min, TimeZone timeZone,
1885                            Class<? extends PortalException> clazz)
1886                    throws PortalException {
1887    
1888                    if (!Validator.isGregorianDate(month, day, year)) {
1889                            if (clazz != null) {
1890                                    try {
1891                                            throw clazz.newInstance();
1892                                    }
1893                                    catch (Exception e) {
1894                                            throw new PortalException(e);
1895                                    }
1896                            }
1897                            else {
1898                                    return null;
1899                            }
1900                    }
1901                    else {
1902                            Calendar cal = null;
1903    
1904                            if (timeZone == null) {
1905                                    cal = CalendarFactoryUtil.getCalendar();
1906                            }
1907                            else {
1908                                    cal = CalendarFactoryUtil.getCalendar(timeZone);
1909                            }
1910    
1911                            if ((hour == -1) || (min == -1)) {
1912                                    cal.set(year, month, day, 0, 0, 0);
1913                            }
1914                            else {
1915                                    cal.set(year, month, day, hour, min, 0);
1916                            }
1917    
1918                            cal.set(Calendar.MILLISECOND, 0);
1919    
1920                            Date date = cal.getTime();
1921    
1922                            /*if ((timeZone != null) &&
1923                                    cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
1924    
1925                                    throw pe;
1926                            }*/
1927    
1928                            return date;
1929                    }
1930            }
1931    
1932            @Override
1933            public Date getDate(
1934                            int month, int day, int year, TimeZone timeZone,
1935                            Class<? extends PortalException> clazz)
1936                    throws PortalException {
1937    
1938                    return getDate(month, day, year, -1, -1, timeZone, clazz);
1939            }
1940    
1941            @Override
1942            public long getDefaultCompanyId() {
1943                    return PortalInstances.getDefaultCompanyId();
1944            }
1945    
1946            @Override
1947            public long getDigestAuthUserId(HttpServletRequest request)
1948                    throws PortalException, SystemException {
1949    
1950                    long userId = 0;
1951    
1952                    String authorizationHeader = request.getHeader(
1953                            HttpHeaders.AUTHORIZATION);
1954    
1955                    if (Validator.isNull(authorizationHeader) ||
1956                            !authorizationHeader.startsWith("Digest ")) {
1957    
1958                            return userId;
1959                    }
1960    
1961                    authorizationHeader = authorizationHeader.substring("Digest ".length());
1962                    authorizationHeader = StringUtil.replace(
1963                            authorizationHeader, CharPool.COMMA, CharPool.NEW_LINE);
1964    
1965                    UnicodeProperties authorizationProperties = new UnicodeProperties();
1966    
1967                    authorizationProperties.fastLoad(authorizationHeader);
1968    
1969                    String username = StringUtil.unquote(
1970                            authorizationProperties.getProperty("username"));
1971                    String realm = StringUtil.unquote(
1972                            authorizationProperties.getProperty("realm"));
1973                    String nonce = StringUtil.unquote(
1974                            authorizationProperties.getProperty("nonce"));
1975                    String uri = StringUtil.unquote(
1976                            authorizationProperties.getProperty("uri"));
1977                    String response = StringUtil.unquote(
1978                            authorizationProperties.getProperty("response"));
1979    
1980                    if (Validator.isNull(username) || Validator.isNull(realm) ||
1981                            Validator.isNull(nonce) || Validator.isNull(uri) ||
1982                            Validator.isNull(response)) {
1983    
1984                            return userId;
1985                    }
1986    
1987                    if (!realm.equals(PORTAL_REALM) ||
1988                            !uri.equals(request.getRequestURI())) {
1989    
1990                            return userId;
1991                    }
1992    
1993                    if (!NonceUtil.verify(nonce)) {
1994                            return userId;
1995                    }
1996    
1997                    long companyId = PortalInstances.getCompanyId(request);
1998    
1999                    userId = UserLocalServiceUtil.authenticateForDigest(
2000                            companyId, username, realm, nonce, request.getMethod(), uri,
2001                            response);
2002    
2003                    return userId;
2004            }
2005    
2006            @Override
2007            public String getDisplayURL(Group group, ThemeDisplay themeDisplay)
2008                    throws PortalException {
2009    
2010                    return getDisplayURL(group, themeDisplay, false);
2011            }
2012    
2013            @Override
2014            public String getDisplayURL(
2015                            Group group, ThemeDisplay themeDisplay, boolean privateLayout)
2016                    throws PortalException {
2017    
2018                    String portalURL = themeDisplay.getPortalURL();
2019    
2020                    if ((privateLayout && (group.getPrivateLayoutsPageCount() > 0)) ||
2021                            (!privateLayout && (group.getPublicLayoutsPageCount() > 0))) {
2022    
2023                            StringBundler sb = new StringBundler(5);
2024    
2025                            sb.append(portalURL);
2026                            sb.append(themeDisplay.getPathMain());
2027                            sb.append("/my_sites/view?groupId=");
2028                            sb.append(group.getGroupId());
2029    
2030                            if (privateLayout) {
2031                                    sb.append("&privateLayout=1");
2032                            }
2033                            else {
2034                                    sb.append("&privateLayout=0");
2035                            }
2036    
2037                            return PortalUtil.addPreservedParameters(
2038                                    themeDisplay, sb.toString());
2039                    }
2040    
2041                    return StringPool.BLANK;
2042            }
2043    
2044            @Override
2045            public String getEmailFromAddress(
2046                            PortletPreferences preferences, long companyId, String defaultValue)
2047                    throws SystemException {
2048    
2049                    if (Validator.isNull(defaultValue)) {
2050                            defaultValue = PrefsPropsUtil.getString(
2051                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_ADDRESS);
2052                    }
2053    
2054                    return preferences.getValue("emailFromAddress", defaultValue);
2055            }
2056    
2057            @Override
2058            public String getEmailFromName(
2059                            PortletPreferences preferences, long companyId, String defaultValue)
2060                    throws SystemException {
2061    
2062                    if (Validator.isNull(defaultValue)) {
2063                            defaultValue = PrefsPropsUtil.getString(
2064                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_NAME);
2065                    }
2066    
2067                    return preferences.getValue("emailFromName", defaultValue);
2068            }
2069    
2070            @Override
2071            public Map<String, Serializable> getExpandoBridgeAttributes(
2072                            ExpandoBridge expandoBridge, HttpServletRequest request)
2073                    throws PortalException, SystemException {
2074    
2075                    Map<String, Serializable> attributes =
2076                            new HashMap<String, Serializable>();
2077    
2078                    List<String> names = new ArrayList<String>();
2079    
2080                    Enumeration<String> enu = request.getParameterNames();
2081    
2082                    while (enu.hasMoreElements()) {
2083                            String param = enu.nextElement();
2084    
2085                            if (param.contains("ExpandoAttributeName--")) {
2086                                    String name = ParamUtil.getString(request, param);
2087    
2088                                    names.add(name);
2089                            }
2090                    }
2091    
2092                    for (String name : names) {
2093                            int type = expandoBridge.getAttributeType(name);
2094    
2095                            UnicodeProperties properties = expandoBridge.getAttributeProperties(
2096                                    name);
2097    
2098                            String displayType = GetterUtil.getString(
2099                                    properties.getProperty(
2100                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
2101                                    ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
2102    
2103                            Serializable value = getExpandoValue(
2104                                    request, "ExpandoAttribute--" + name + "--", type, displayType);
2105    
2106                            attributes.put(name, value);
2107                    }
2108    
2109                    return attributes;
2110            }
2111    
2112            @Override
2113            public Map<String, Serializable> getExpandoBridgeAttributes(
2114                            ExpandoBridge expandoBridge, PortletRequest portletRequest)
2115                    throws PortalException, SystemException {
2116    
2117                    return getExpandoBridgeAttributes(
2118                            expandoBridge, getHttpServletRequest(portletRequest));
2119            }
2120    
2121            @Override
2122            public Map<String, Serializable> getExpandoBridgeAttributes(
2123                            ExpandoBridge expandoBridge,
2124                            UploadPortletRequest uploadPortletRequest)
2125                    throws PortalException, SystemException {
2126    
2127                    return getExpandoBridgeAttributes(
2128                            expandoBridge, (HttpServletRequest)uploadPortletRequest);
2129            }
2130    
2131            @Override
2132            public Serializable getExpandoValue(
2133                            HttpServletRequest request, String name, int type,
2134                            String displayType)
2135                    throws PortalException, SystemException {
2136    
2137                    Serializable value = null;
2138    
2139                    if (type == ExpandoColumnConstants.BOOLEAN) {
2140                            value = ParamUtil.getBoolean(request, name);
2141                    }
2142                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2143                    }
2144                    else if (type == ExpandoColumnConstants.DATE) {
2145                            int valueDateMonth = ParamUtil.getInteger(request, name + "Month");
2146                            int valueDateDay = ParamUtil.getInteger(request, name + "Day");
2147                            int valueDateYear = ParamUtil.getInteger(request, name + "Year");
2148                            int valueDateHour = ParamUtil.getInteger(request, name + "Hour");
2149                            int valueDateMinute = ParamUtil.getInteger(
2150                                    request, name + "Minute");
2151                            int valueDateAmPm = ParamUtil.getInteger(request, name + "AmPm");
2152    
2153                            if (valueDateAmPm == Calendar.PM) {
2154                                    valueDateHour += 12;
2155                            }
2156    
2157                            TimeZone timeZone = null;
2158    
2159                            User user = getUser(request);
2160    
2161                            if (user != null) {
2162                                    timeZone = user.getTimeZone();
2163                            }
2164    
2165                            value = getDate(
2166                                    valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
2167                                    valueDateMinute, timeZone, ValueDataException.class);
2168                    }
2169                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2170                    }
2171                    else if (type == ExpandoColumnConstants.DOUBLE) {
2172                            value = ParamUtil.getDouble(request, name);
2173                    }
2174                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2175                            String[] values = request.getParameterValues(name);
2176    
2177                            if (displayType.equals(
2178                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2179                                    !ArrayUtil.isEmpty(values)) {
2180    
2181                                    values = StringUtil.splitLines(values[0]);
2182                            }
2183    
2184                            value = GetterUtil.getDoubleValues(values);
2185                    }
2186                    else if (type == ExpandoColumnConstants.FLOAT) {
2187                            value = ParamUtil.getFloat(request, name);
2188                    }
2189                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2190                            String[] values = request.getParameterValues(name);
2191    
2192                            if (displayType.equals(
2193                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2194                                    !ArrayUtil.isEmpty(values)) {
2195    
2196                                    values = StringUtil.splitLines(values[0]);
2197                            }
2198    
2199                            value = GetterUtil.getFloatValues(values);
2200                    }
2201                    else if (type == ExpandoColumnConstants.INTEGER) {
2202                            value = ParamUtil.getInteger(request, name);
2203                    }
2204                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2205                            String[] values = request.getParameterValues(name);
2206    
2207                            if (displayType.equals(
2208                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2209                                    !ArrayUtil.isEmpty(values)) {
2210    
2211                                    values = StringUtil.splitLines(values[0]);
2212                            }
2213    
2214                            value = GetterUtil.getIntegerValues(values);
2215                    }
2216                    else if (type == ExpandoColumnConstants.LONG) {
2217                            value = ParamUtil.getLong(request, name);
2218                    }
2219                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2220                            String[] values = request.getParameterValues(name);
2221    
2222                            if (displayType.equals(
2223                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2224                                    !ArrayUtil.isEmpty(values)) {
2225    
2226                                    values = StringUtil.splitLines(values[0]);
2227                            }
2228    
2229                            value = GetterUtil.getLongValues(values);
2230                    }
2231                    else if (type == ExpandoColumnConstants.NUMBER) {
2232                            value = ParamUtil.getNumber(request, name);
2233                    }
2234                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2235                            String[] values = request.getParameterValues(name);
2236    
2237                            if (displayType.equals(
2238                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2239                                    !ArrayUtil.isEmpty(values)) {
2240    
2241                                    values = StringUtil.splitLines(values[0]);
2242                            }
2243    
2244                            value = GetterUtil.getNumberValues(values);
2245                    }
2246                    else if (type == ExpandoColumnConstants.SHORT) {
2247                            value = ParamUtil.getShort(request, name);
2248                    }
2249                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2250                            String[] values = request.getParameterValues(name);
2251    
2252                            if (displayType.equals(
2253                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2254                                    !ArrayUtil.isEmpty(values)) {
2255    
2256                                    values = StringUtil.splitLines(values[0]);
2257                            }
2258    
2259                            value = GetterUtil.getShortValues(values);
2260                    }
2261                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2262                            String[] values = request.getParameterValues(name);
2263    
2264                            if (displayType.equals(
2265                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX) &&
2266                                    !ArrayUtil.isEmpty(values)) {
2267    
2268                                    values = StringUtil.splitLines(values[0]);
2269                            }
2270    
2271                            value = values;
2272                    }
2273                    else if (type == ExpandoColumnConstants.STRING_LOCALIZED) {
2274                            value = (Serializable)LocalizationUtil.getLocalizationMap(
2275                                    request, name);
2276                    }
2277                    else {
2278                            value = ParamUtil.getString(request, name);
2279                    }
2280    
2281                    return value;
2282            }
2283    
2284            @Override
2285            public Serializable getExpandoValue(
2286                            PortletRequest portletRequest, String name, int type,
2287                            String displayType)
2288                    throws PortalException, SystemException {
2289    
2290                    return getExpandoValue(
2291                            getHttpServletRequest(portletRequest), name, type, displayType);
2292            }
2293    
2294            @Override
2295            public Serializable getExpandoValue(
2296                            UploadPortletRequest uploadPortletRequest, String name, int type,
2297                            String displayType)
2298                    throws PortalException, SystemException {
2299    
2300                    return getExpandoValue(
2301                            (HttpServletRequest)uploadPortletRequest, name, type, displayType);
2302            }
2303    
2304            @Override
2305            public String getFacebookURL(
2306                            Portlet portlet, String facebookCanvasPageURL,
2307                            ThemeDisplay themeDisplay)
2308                    throws PortalException, SystemException {
2309    
2310                    String facebookURL = getServletURL(
2311                            portlet, FacebookUtil.FACEBOOK_SERVLET_PATH + facebookCanvasPageURL,
2312                            themeDisplay);
2313    
2314                    if (!facebookURL.endsWith(StringPool.SLASH)) {
2315                            facebookURL += StringPool.SLASH;
2316                    }
2317    
2318                    return facebookURL;
2319            }
2320    
2321            @Override
2322            public Portlet getFirstMyAccountPortlet(ThemeDisplay themeDisplay)
2323                    throws SystemException {
2324    
2325                    List<Portlet> portlets = getControlPanelPortlets(
2326                            PortletCategoryKeys.MY, themeDisplay);
2327    
2328                    if (portlets.isEmpty()) {
2329                            return null;
2330                    }
2331    
2332                    return portlets.get(0);
2333            }
2334    
2335            @Override
2336            public String getFirstPageLayoutTypes(PageContext pageContext) {
2337                    StringBundler sb = new StringBundler();
2338    
2339                    for (String type : PropsValues.LAYOUT_TYPES) {
2340                            if (isLayoutFirstPageable(type)) {
2341                                    sb.append(
2342                                            LanguageUtil.get(pageContext, "layout.types." + type));
2343                                    sb.append(StringPool.COMMA);
2344                                    sb.append(StringPool.SPACE);
2345                            }
2346                    }
2347    
2348                    if (sb.index() >= 2) {
2349                            sb.setIndex(sb.index() - 2);
2350                    }
2351    
2352                    return sb.toString();
2353            }
2354    
2355            @Override
2356            public Portlet getFirstSiteAdministrationPortlet(ThemeDisplay themeDisplay)
2357                    throws SystemException {
2358    
2359                    Portlet siteAdministrationPortlet = null;
2360    
2361                    for (String category : PortletCategoryKeys.SITE_ADMINISTRATION_ALL) {
2362                            List<Portlet> portlets = getControlPanelPortlets(
2363                                    category, themeDisplay);
2364    
2365                            if (portlets.isEmpty()) {
2366                                    continue;
2367                            }
2368    
2369                            return portlets.get(0);
2370                    }
2371    
2372                    return siteAdministrationPortlet;
2373            }
2374    
2375            @Override
2376            public String getFullName(
2377                    String firstName, String middleName, String lastName) {
2378    
2379                    FullNameGenerator fullNameGenerator =
2380                            FullNameGeneratorFactory.getInstance();
2381    
2382                    return fullNameGenerator.getFullName(firstName, middleName, lastName);
2383            }
2384    
2385            @Override
2386            public String getGlobalLibDir() {
2387                    return PropsValues.LIFERAY_LIB_GLOBAL_DIR;
2388            }
2389    
2390            @Override
2391            public String getGoogleGadgetURL(Portlet portlet, ThemeDisplay themeDisplay)
2392                    throws PortalException, SystemException {
2393    
2394                    return getServletURL(
2395                            portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
2396            }
2397    
2398            @Override
2399            public String getGroupFriendlyURL(
2400                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay)
2401                    throws PortalException, SystemException {
2402    
2403                    LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
2404                            group.getGroupId(), privateLayoutSet);
2405    
2406                    return getGroupFriendlyURL(layoutSet, themeDisplay, false);
2407            }
2408    
2409            @Override
2410            public String getGroupFriendlyURL(
2411                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
2412                            Locale locale)
2413                    throws PortalException, SystemException {
2414    
2415                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
2416                    String i18nPath = themeDisplay.getI18nPath();
2417                    Locale originalLocale = themeDisplay.getLocale();
2418    
2419                    try {
2420                            setThemeDisplayI18n(themeDisplay, locale);
2421    
2422                            return getGroupFriendlyURL(group, privateLayoutSet, themeDisplay);
2423                    }
2424                    finally {
2425                            resetThemeDisplayI18n(
2426                                    themeDisplay, i18nLanguageId, i18nPath, originalLocale);
2427                    }
2428            }
2429    
2430            @Override
2431            public int[] getGroupFriendlyURLIndex(String requestURI) {
2432                    if (requestURI.startsWith(
2433                                    _PRIVATE_GROUP_SERVLET_MAPPING + StringPool.SLASH) ||
2434                            requestURI.startsWith(
2435                                    _PRIVATE_USER_SERVLET_MAPPING + StringPool.SLASH) ||
2436                            requestURI.startsWith(
2437                                    _PUBLIC_GROUP_SERVLET_MAPPING + StringPool.SLASH)) {
2438    
2439                            int x = requestURI.indexOf(StringPool.SLASH, 1);
2440    
2441                            int y = requestURI.indexOf(CharPool.SLASH, x + 1);
2442    
2443                            if (y == -1) {
2444    
2445                                    // /web/alpha
2446    
2447                                    requestURI += StringPool.SLASH;
2448    
2449                                    y = requestURI.indexOf(CharPool.SLASH, x + 1);
2450                            }
2451    
2452                            return new int[] {x, y};
2453                    }
2454    
2455                    return null;
2456            }
2457    
2458            @Override
2459            public String[] getGroupPermissions(HttpServletRequest request) {
2460                    return request.getParameterValues("groupPermissions");
2461            }
2462    
2463            @Override
2464            public String[] getGroupPermissions(
2465                    HttpServletRequest request, String className) {
2466    
2467                    String[] groupPermissions = request.getParameterValues(
2468                            "groupPermissions_" + className);
2469    
2470                    String inputPermissionsShowOptions = request.getParameter(
2471                            "inputPermissionsShowOptions");
2472    
2473                    return getGroupPermissions(
2474                            groupPermissions, className, inputPermissionsShowOptions);
2475            }
2476    
2477            @Override
2478            public String[] getGroupPermissions(PortletRequest portletRequest) {
2479                    return portletRequest.getParameterValues("groupPermissions");
2480            }
2481    
2482            @Override
2483            public String[] getGroupPermissions(
2484                    PortletRequest portletRequest, String className) {
2485    
2486                    String[] groupPermissions = portletRequest.getParameterValues(
2487                            "groupPermissions_" + className);
2488    
2489                    String inputPermissionsShowOptions = portletRequest.getParameter(
2490                            "inputPermissionsShowOptions");
2491    
2492                    return getGroupPermissions(
2493                            groupPermissions, className, inputPermissionsShowOptions);
2494            }
2495    
2496            @Override
2497            public String[] getGuestPermissions(HttpServletRequest request) {
2498                    return request.getParameterValues("guestPermissions");
2499            }
2500    
2501            @Override
2502            public String[] getGuestPermissions(
2503                    HttpServletRequest request, String className) {
2504    
2505                    String[] guestPermissions = request.getParameterValues(
2506                            "guestPermissions_" + className);
2507    
2508                    String inputPermissionsShowOptions = request.getParameter(
2509                            "inputPermissionsShowOptions");
2510    
2511                    return getGuestPermissions(
2512                            guestPermissions, className, inputPermissionsShowOptions);
2513            }
2514    
2515            @Override
2516            public String[] getGuestPermissions(PortletRequest portletRequest) {
2517                    return portletRequest.getParameterValues("guestPermissions");
2518            }
2519    
2520            @Override
2521            public String[] getGuestPermissions(
2522                    PortletRequest portletRequest, String className) {
2523    
2524                    String[] guestPermissions = portletRequest.getParameterValues(
2525                            "guestPermissions_" + className);
2526    
2527                    String inputPermissionsShowOptions = portletRequest.getParameter(
2528                            "inputPermissionsShowOptions");
2529    
2530                    return getGuestPermissions(
2531                            guestPermissions, className, inputPermissionsShowOptions);
2532            }
2533    
2534            @Override
2535            public String getHomeURL(HttpServletRequest request)
2536                    throws PortalException, SystemException {
2537    
2538                    String portalURL = getPortalURL(request);
2539    
2540                    return portalURL + _pathContext + getRelativeHomeURL(request);
2541            }
2542    
2543            @Override
2544            public String getHost(HttpServletRequest request) {
2545                    request = getOriginalServletRequest(request);
2546    
2547                    String host = request.getHeader("Host");
2548    
2549                    if (host != null) {
2550                            host = StringUtil.toLowerCase(host.trim());
2551    
2552                            int pos = host.indexOf(':');
2553    
2554                            if (pos >= 0) {
2555                                    host = host.substring(0, pos);
2556                            }
2557                    }
2558                    else {
2559                            host = null;
2560                    }
2561    
2562                    return host;
2563            }
2564    
2565            @Override
2566            public String getHost(PortletRequest portletRequest) {
2567                    return getHost(getHttpServletRequest(portletRequest));
2568            }
2569    
2570            @Override
2571            public HttpServletRequest getHttpServletRequest(
2572                    PortletRequest portletRequest) {
2573    
2574                    PortletRequestImpl portletRequestImpl =
2575                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
2576    
2577                    return portletRequestImpl.getHttpServletRequest();
2578            }
2579    
2580            @Override
2581            public HttpServletResponse getHttpServletResponse(
2582                    PortletResponse portletResponse) {
2583    
2584                    PortletResponseImpl portletResponseImpl =
2585                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
2586    
2587                    return portletResponseImpl.getHttpServletResponse();
2588            }
2589    
2590            @Override
2591            public String getI18nPathLanguageId(
2592                    Locale locale, String defaultI18nPathLanguageId) {
2593    
2594                    String i18nPathLanguageId = defaultI18nPathLanguageId;
2595    
2596                    if (!LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
2597                            i18nPathLanguageId = locale.getLanguage();
2598                    }
2599                    else {
2600                            Locale priorityLocale = LanguageUtil.getLocale(
2601                                    locale.getLanguage());
2602    
2603                            if (locale.equals(priorityLocale)) {
2604                                    i18nPathLanguageId = locale.getLanguage();
2605                            }
2606                    }
2607    
2608                    return i18nPathLanguageId;
2609            }
2610    
2611            @Override
2612            public String getJournalArticleActualURL(
2613                            long groupId, boolean privateLayout, String mainPath,
2614                            String friendlyURL, Map<String, String[]> params,
2615                            Map<String, Object> requestContext)
2616                    throws PortalException, SystemException {
2617    
2618                    String urlTitle = friendlyURL.substring(
2619                            JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
2620    
2621                    JournalArticle journalArticle =
2622                            JournalArticleLocalServiceUtil.getArticleByUrlTitle(
2623                                    groupId, urlTitle);
2624    
2625                    Layout layout = getJournalArticleLayout(
2626                            groupId, privateLayout, friendlyURL);
2627    
2628                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
2629    
2630                    InheritableMap<String, String[]> actualParams =
2631                            new InheritableMap<String, String[]>();
2632    
2633                    if (params != null) {
2634                            actualParams.setParentMap(params);
2635                    }
2636    
2637                    UnicodeProperties typeSettingsProperties =
2638                            layout.getTypeSettingsProperties();
2639    
2640                    String defaultAssetPublisherPortletId = typeSettingsProperties.get(
2641                            LayoutTypePortletConstants.DEFAULT_ASSET_PUBLISHER_PORTLET_ID);
2642    
2643                    String currentDefaultAssetPublisherPortletId =
2644                            defaultAssetPublisherPortletId;
2645    
2646                    if (Validator.isNull(defaultAssetPublisherPortletId)) {
2647                            String instanceId = LayoutTypePortletImpl.generateInstanceId();
2648    
2649                            defaultAssetPublisherPortletId = PortletConstants.assemblePortletId(
2650                                    PortletKeys.ASSET_PUBLISHER, instanceId);
2651                    }
2652    
2653                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
2654                            "request");
2655    
2656                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2657                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
2658                                    request, layout.getPlid(), defaultAssetPublisherPortletId);
2659    
2660                            actualParams.put(
2661                                    "p_p_auth", new String[] {actualPortletAuthenticationToken});
2662                    }
2663    
2664                    actualParams.put(
2665                            "p_p_id", new String[] {defaultAssetPublisherPortletId});
2666                    actualParams.put("p_p_lifecycle", new String[] {"0"});
2667    
2668                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2669                            actualParams.put(
2670                                    "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
2671                    }
2672    
2673                    actualParams.put("p_p_mode", new String[] {"view"});
2674                    actualParams.put(
2675                            "p_j_a_id", new String[] {String.valueOf(journalArticle.getId())});
2676    
2677                    String namespace = getPortletNamespace(defaultAssetPublisherPortletId);
2678    
2679                    actualParams.put(
2680                            namespace + "struts_action",
2681                            new String[] {"/asset_publisher/view_content"});
2682                    actualParams.put(
2683                            namespace + "type",
2684                            new String[] {JournalArticleAssetRendererFactory.TYPE});
2685                    actualParams.put(
2686                            namespace + "urlTitle",
2687                            new String[] {journalArticle.getUrlTitle()});
2688    
2689                    String queryString = HttpUtil.parameterMapToString(actualParams, false);
2690    
2691                    if (layoutActualURL.contains(StringPool.QUESTION)) {
2692                            layoutActualURL =
2693                                    layoutActualURL + StringPool.AMPERSAND + queryString;
2694                    }
2695                    else {
2696                            layoutActualURL =
2697                                    layoutActualURL + StringPool.QUESTION + queryString;
2698                    }
2699    
2700                    Locale locale = getLocale(request);
2701    
2702                    addPageSubtitle(journalArticle.getTitle(locale), request);
2703                    addPageDescription(journalArticle.getDescription(locale), request);
2704    
2705                    List<AssetTag> assetTags = AssetTagLocalServiceUtil.getTags(
2706                            JournalArticle.class.getName(), journalArticle.getPrimaryKey());
2707    
2708                    if (!assetTags.isEmpty()) {
2709                            addPageKeywords(
2710                                    ListUtil.toString(assetTags, AssetTag.NAME_ACCESSOR), request);
2711                    }
2712    
2713                    return layoutActualURL;
2714            }
2715    
2716            @Override
2717            public Layout getJournalArticleLayout(
2718                            long groupId, boolean privateLayout, String friendlyURL)
2719                    throws PortalException, SystemException {
2720    
2721                    String urlTitle = friendlyURL.substring(
2722                            JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
2723    
2724                    JournalArticle journalArticle =
2725                            JournalArticleLocalServiceUtil.getArticleByUrlTitle(
2726                                    groupId, urlTitle);
2727    
2728                    return LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
2729                            journalArticle.getLayoutUuid(), groupId, privateLayout);
2730            }
2731    
2732            @Override
2733            public String getJsSafePortletId(String portletId) {
2734                    return JS.getSafeName(portletId);
2735            }
2736    
2737            @Override
2738            public String getLayoutActualURL(Layout layout) {
2739                    return getLayoutActualURL(layout, getPathMain());
2740            }
2741    
2742            @Override
2743            public String getLayoutActualURL(Layout layout, String mainPath) {
2744                    Map<String, String> variables = new HashMap<String, String>();
2745    
2746                    variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
2747                    variables.put("liferay:mainPath", mainPath);
2748                    variables.put("liferay:plid", String.valueOf(layout.getPlid()));
2749    
2750                    if (layout instanceof VirtualLayout) {
2751                            variables.put(
2752                                    "liferay:pvlsgid", String.valueOf(layout.getGroupId()));
2753                    }
2754                    else {
2755                            variables.put("liferay:pvlsgid", "0");
2756                    }
2757    
2758                    LayoutType layoutType = layout.getLayoutType();
2759    
2760                    UnicodeProperties typeSettingsProperties =
2761                            layoutType.getTypeSettingsProperties();
2762    
2763                    variables.putAll(typeSettingsProperties);
2764    
2765                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
2766    
2767                    return layoutSettings.getURL(variables);
2768            }
2769    
2770            @Override
2771            public String getLayoutActualURL(
2772                            long groupId, boolean privateLayout, String mainPath,
2773                            String friendlyURL)
2774                    throws PortalException, SystemException {
2775    
2776                    return getLayoutActualURL(
2777                            groupId, privateLayout, mainPath, friendlyURL, null, null);
2778            }
2779    
2780            @Override
2781            public String getLayoutActualURL(
2782                            long groupId, boolean privateLayout, String mainPath,
2783                            String friendlyURL, Map<String, String[]> params,
2784                            Map<String, Object> requestContext)
2785                    throws PortalException, SystemException {
2786    
2787                    LayoutQueryStringComposite actualLayoutQueryStringComposite =
2788                            getActualLayoutQueryStringComposite(
2789                                    groupId, privateLayout, friendlyURL, params, requestContext);
2790    
2791                    Layout layout = actualLayoutQueryStringComposite.getLayout();
2792                    String queryString = actualLayoutQueryStringComposite.getQueryString();
2793    
2794                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
2795    
2796                    if (Validator.isNotNull(queryString)) {
2797                            layoutActualURL = layoutActualURL.concat(queryString);
2798                    }
2799                    else if (params.isEmpty()) {
2800                            LayoutType layoutType = layout.getLayoutType();
2801    
2802                            UnicodeProperties typeSettingsProperties =
2803                                    layoutType.getTypeSettingsProperties();
2804    
2805                            queryString = typeSettingsProperties.getProperty("query-string");
2806    
2807                            if (Validator.isNotNull(queryString) &&
2808                                    layoutActualURL.contains(StringPool.QUESTION)) {
2809    
2810                                    layoutActualURL = layoutActualURL.concat(
2811                                            StringPool.AMPERSAND).concat(queryString);
2812                            }
2813                    }
2814    
2815                    return layoutActualURL;
2816            }
2817    
2818            @Override
2819            public String getLayoutEditPage(Layout layout) {
2820                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
2821                            layout.getType());
2822    
2823                    return layoutSettings.getEditPage();
2824            }
2825    
2826            @Override
2827            public String getLayoutEditPage(String type) {
2828                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2829    
2830                    return layoutSettings.getEditPage();
2831            }
2832    
2833            @Override
2834            public String getLayoutFriendlyURL(Layout layout, ThemeDisplay themeDisplay)
2835                    throws PortalException, SystemException {
2836    
2837                    if (!isLayoutFriendliable(layout)) {
2838                            return null;
2839                    }
2840    
2841                    String groupFriendlyURL = getGroupFriendlyURL(
2842                            layout.getLayoutSet(), themeDisplay, false);
2843    
2844                    return groupFriendlyURL.concat(
2845                            layout.getFriendlyURL(themeDisplay.getLocale()));
2846            }
2847    
2848            @Override
2849            public String getLayoutFriendlyURL(
2850                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
2851                    throws PortalException, SystemException {
2852    
2853                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
2854                    String i18nPath = themeDisplay.getI18nPath();
2855                    Locale originalLocale = themeDisplay.getLocale();
2856    
2857                    try {
2858                            setThemeDisplayI18n(themeDisplay, locale);
2859    
2860                            return getLayoutFriendlyURL(layout, themeDisplay);
2861                    }
2862                    finally {
2863                            resetThemeDisplayI18n(
2864                                    themeDisplay, i18nLanguageId, i18nPath, originalLocale);
2865                    }
2866            }
2867    
2868            @Override
2869            public LayoutFriendlyURLComposite getLayoutFriendlyURLComposite(
2870                            long groupId, boolean privateLayout, String friendlyURL,
2871                            Map<String, String[]> params, Map<String, Object> requestContext)
2872                    throws PortalException, SystemException {
2873    
2874                    Layout layout = null;
2875                    String layoutFriendlyURL = friendlyURL;
2876    
2877                    if (friendlyURL != null) {
2878                            if (friendlyURL.startsWith(
2879                                            JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
2880    
2881                                    try {
2882                                            layout = getJournalArticleLayout(
2883                                                    groupId, privateLayout, friendlyURL);
2884                                    }
2885                                    catch (Exception e) {
2886                                            throw new NoSuchLayoutException(e);
2887                                    }
2888                            }
2889                            else if (friendlyURL.startsWith(
2890                                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
2891    
2892                                    try {
2893                                            LayoutFriendlyURLComposite layoutFriendlyURLComposite =
2894                                                    getVirtualLayoutFriendlyURLComposite(
2895                                                            privateLayout, friendlyURL, params, requestContext);
2896    
2897                                            layout = layoutFriendlyURLComposite.getLayout();
2898                                            layoutFriendlyURL =
2899                                                    layoutFriendlyURLComposite.getFriendlyURL();
2900                                    }
2901                                    catch (Exception e) {
2902                                            throw new NoSuchLayoutException(e);
2903                                    }
2904                            }
2905                    }
2906    
2907                    if (layout == null) {
2908                            LayoutQueryStringComposite layoutQueryStringComposite =
2909                                    getActualLayoutQueryStringComposite(
2910                                            groupId, privateLayout, friendlyURL, params,
2911                                            requestContext);
2912    
2913                            layout = layoutQueryStringComposite.getLayout();
2914                            layoutFriendlyURL = layoutQueryStringComposite.getFriendlyURL();
2915                    }
2916    
2917                    return new LayoutFriendlyURLComposite(layout, layoutFriendlyURL);
2918            }
2919    
2920            @Override
2921            public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
2922                    throws PortalException, SystemException {
2923    
2924                    return getLayoutFullURL(layout, themeDisplay, true);
2925            }
2926    
2927            @Override
2928            public String getLayoutFullURL(
2929                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2930                    throws PortalException, SystemException {
2931    
2932                    String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
2933    
2934                    if (!HttpUtil.hasProtocol(layoutURL)) {
2935                            layoutURL = getPortalURL(layout, themeDisplay) + (layoutURL);
2936                    }
2937    
2938                    return layoutURL;
2939            }
2940    
2941            @Override
2942            public String getLayoutFullURL(long groupId, String portletId)
2943                    throws PortalException, SystemException {
2944    
2945                    return getLayoutFullURL(groupId, portletId, false);
2946            }
2947    
2948            @Override
2949            public String getLayoutFullURL(
2950                            long groupId, String portletId, boolean secure)
2951                    throws PortalException, SystemException {
2952    
2953                    long plid = getPlidFromPortletId(groupId, portletId);
2954    
2955                    if (plid == LayoutConstants.DEFAULT_PLID) {
2956                            return null;
2957                    }
2958    
2959                    StringBundler sb = new StringBundler(4);
2960    
2961                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2962    
2963                    Group group = GroupLocalServiceUtil.getGroup(groupId);
2964    
2965                    if (group.isLayout()) {
2966                            long parentGroupId = group.getParentGroupId();
2967    
2968                            if (parentGroupId > 0) {
2969                                    group = GroupLocalServiceUtil.getGroup(parentGroupId);
2970                            }
2971                    }
2972    
2973                    String virtualHostname = null;
2974    
2975                    LayoutSet layoutSet = layout.getLayoutSet();
2976    
2977                    if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
2978                            virtualHostname = layoutSet.getVirtualHostname();
2979                    }
2980                    else {
2981                            Company company = CompanyLocalServiceUtil.getCompany(
2982                                    layout.getCompanyId());
2983    
2984                            virtualHostname = company.getVirtualHostname();
2985                    }
2986    
2987                    String portalURL = getPortalURL(
2988                            virtualHostname, getPortalPort(secure), secure);
2989    
2990                    sb.append(portalURL);
2991    
2992                    if (layout.isPrivateLayout()) {
2993                            if (group.isUser()) {
2994                                    sb.append(getPathFriendlyURLPrivateUser());
2995                            }
2996                            else {
2997                                    sb.append(getPathFriendlyURLPrivateGroup());
2998                            }
2999                    }
3000                    else {
3001                            sb.append(getPathFriendlyURLPublic());
3002                    }
3003    
3004                    sb.append(group.getFriendlyURL());
3005                    sb.append(layout.getFriendlyURL());
3006    
3007                    return sb.toString();
3008            }
3009    
3010            @Override
3011            public String getLayoutFullURL(ThemeDisplay themeDisplay)
3012                    throws PortalException, SystemException {
3013    
3014                    return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
3015            }
3016    
3017            @Override
3018            public String getLayoutSetFriendlyURL(
3019                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
3020                    throws PortalException, SystemException {
3021    
3022                    String virtualHostname = getVirtualHostname(layoutSet);
3023    
3024                    if (Validator.isNull(virtualHostname) &&
3025                            Validator.isNotNull(PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
3026                            !layoutSet.isPrivateLayout()) {
3027    
3028                            try {
3029                                    Group group = GroupLocalServiceUtil.getGroup(
3030                                            themeDisplay.getCompanyId(),
3031                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
3032    
3033                                    if (layoutSet.getGroupId() == group.getGroupId()) {
3034                                            Company company = themeDisplay.getCompany();
3035    
3036                                            virtualHostname = company.getVirtualHostname();
3037                                    }
3038                            }
3039                            catch (Exception e) {
3040                                    _log.error(e, e);
3041                            }
3042                    }
3043    
3044                    if (Validator.isNotNull(virtualHostname) &&
3045                            !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
3046    
3047                            String portalURL = getPortalURL(
3048                                    virtualHostname, themeDisplay.getServerPort(),
3049                                    themeDisplay.isSecure());
3050    
3051                            // Use the layout set's virtual host setting only if the layout set
3052                            // is already used for the current request
3053    
3054                            long curLayoutSetId =
3055                                    themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
3056    
3057                            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
3058                                    portalURL.startsWith(themeDisplay.getURLPortal())) {
3059    
3060                                    String layoutSetFriendlyURL = portalURL + _pathContext;
3061    
3062                                    if (themeDisplay.isI18n()) {
3063                                            layoutSetFriendlyURL += themeDisplay.getI18nPath();
3064                                    }
3065    
3066                                    return addPreservedParameters(
3067                                            themeDisplay, layoutSetFriendlyURL);
3068                            }
3069                    }
3070    
3071                    Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
3072    
3073                    String friendlyURL = null;
3074    
3075                    if (layoutSet.isPrivateLayout()) {
3076                            if (group.isUser()) {
3077                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
3078                            }
3079                            else {
3080                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
3081                            }
3082                    }
3083                    else {
3084                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
3085                    }
3086    
3087                    if (themeDisplay.isI18n()) {
3088                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
3089                    }
3090    
3091                    String layoutSetFriendlyURL =
3092                            _pathContext + friendlyURL + group.getFriendlyURL();
3093    
3094                    return addPreservedParameters(themeDisplay, layoutSetFriendlyURL);
3095            }
3096    
3097            @Override
3098            public String getLayoutTarget(Layout layout) {
3099                    UnicodeProperties typeSettingsProps =
3100                            layout.getTypeSettingsProperties();
3101    
3102                    String target = typeSettingsProps.getProperty("target");
3103    
3104                    if (Validator.isNull(target)) {
3105                            target = StringPool.BLANK;
3106                    }
3107                    else {
3108                            target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
3109                    }
3110    
3111                    return target;
3112            }
3113    
3114            @Override
3115            public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
3116                    throws PortalException, SystemException {
3117    
3118                    return getLayoutURL(layout, themeDisplay, true);
3119            }
3120    
3121            @Override
3122            public String getLayoutURL(
3123                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
3124                    throws PortalException, SystemException {
3125    
3126                    if (layout == null) {
3127                            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
3128                    }
3129    
3130                    if (!layout.isTypeURL()) {
3131                            String layoutFriendlyURL = getLayoutFriendlyURL(
3132                                    layout, themeDisplay);
3133    
3134                            if (Validator.isNotNull(layoutFriendlyURL)) {
3135                                    layoutFriendlyURL = addPreservedParameters(
3136                                            themeDisplay, layout, layoutFriendlyURL, doAsUser);
3137    
3138                                    return layoutFriendlyURL;
3139                            }
3140                    }
3141    
3142                    String layoutURL = getLayoutActualURL(layout);
3143    
3144                    layoutURL = addPreservedParameters(
3145                            themeDisplay, layout, layoutURL, doAsUser);
3146    
3147                    return layoutURL;
3148            }
3149    
3150            @Override
3151            public String getLayoutURL(
3152                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
3153                    throws PortalException, SystemException {
3154    
3155                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
3156                    String i18nPath = themeDisplay.getI18nPath();
3157                    Locale originalLocale = themeDisplay.getLocale();
3158    
3159                    try {
3160                            setThemeDisplayI18n(themeDisplay, locale);
3161    
3162                            return getLayoutURL(layout, themeDisplay, true);
3163                    }
3164                    finally {
3165                            resetThemeDisplayI18n(
3166                                    themeDisplay, i18nLanguageId, i18nPath, originalLocale);
3167                    }
3168            }
3169    
3170            @Override
3171            public String getLayoutURL(ThemeDisplay themeDisplay)
3172                    throws PortalException, SystemException {
3173    
3174                    return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
3175            }
3176    
3177            @Override
3178            public String getLayoutViewPage(Layout layout) {
3179                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
3180                            layout.getType());
3181    
3182                    return layoutSettings.getViewPage();
3183            }
3184    
3185            @Override
3186            public String getLayoutViewPage(String type) {
3187                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3188    
3189                    return layoutSettings.getViewPage();
3190            }
3191    
3192            @Override
3193            public LiferayPortletRequest getLiferayPortletRequest(
3194                    PortletRequest portletRequest) {
3195    
3196                    PortletRequestImpl portletRequestImpl =
3197                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
3198    
3199                    return DoPrivilegedUtil.wrapWhenActive(portletRequestImpl);
3200            }
3201    
3202            @Override
3203            public LiferayPortletResponse getLiferayPortletResponse(
3204                    PortletResponse portletResponse) {
3205    
3206                    PortletResponseImpl portletResponseImpl =
3207                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
3208    
3209                    return DoPrivilegedUtil.wrapWhenActive(portletResponseImpl);
3210            }
3211    
3212            @Override
3213            public Locale getLocale(HttpServletRequest request) {
3214                    return getLocale(request, null, false);
3215            }
3216    
3217            @Override
3218            public Locale getLocale(
3219                    HttpServletRequest request, HttpServletResponse response,
3220                    boolean initialize) {
3221    
3222                    User user = null;
3223    
3224                    if (initialize) {
3225                            try {
3226                                    user = initUser(request);
3227                            }
3228                            catch (NoSuchUserException nsue) {
3229                                    return null;
3230                            }
3231                            catch (Exception e) {
3232                            }
3233                    }
3234    
3235                    Locale locale = null;
3236    
3237                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3238                            WebKeys.THEME_DISPLAY);
3239    
3240                    if (themeDisplay != null) {
3241                            locale = themeDisplay.getLocale();
3242    
3243                            if (LanguageUtil.isAvailableLocale(
3244                                            themeDisplay.getSiteGroupId(), locale)) {
3245    
3246                                    return locale;
3247                            }
3248                    }
3249    
3250                    long groupId = 0;
3251    
3252                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3253    
3254                    if ((layout != null) && !layout.isTypeControlPanel()) {
3255                            try {
3256                                    long scopeGroupId = getScopeGroupId(request);
3257    
3258                                    groupId = getSiteGroupId(scopeGroupId);
3259                            }
3260                            catch (Exception e) {
3261                            }
3262                    }
3263    
3264                    String i18nLanguageId = (String)request.getAttribute(
3265                            WebKeys.I18N_LANGUAGE_ID);
3266    
3267                    if (Validator.isNotNull(i18nLanguageId)) {
3268                            locale = LocaleUtil.fromLanguageId(i18nLanguageId, true, false);
3269    
3270                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3271                                    return locale;
3272                            }
3273                            else if (groupId > 0) {
3274                                    boolean inheritLocales = true;
3275    
3276                                    try {
3277                                            inheritLocales = LanguageUtil.isInheritLocales(groupId);
3278                                    }
3279                                    catch (Exception pe) {
3280                                            _log.error(pe);
3281                                    }
3282    
3283                                    if (!inheritLocales) {
3284                                            String i18nLanguageCode = (String)request.getAttribute(
3285                                                    WebKeys.I18N_LANGUAGE_CODE);
3286    
3287                                            locale = LanguageUtil.getLocale(groupId, i18nLanguageCode);
3288    
3289                                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3290                                                    return locale;
3291                                            }
3292                                    }
3293                            }
3294                    }
3295    
3296                    String doAsUserLanguageId = ParamUtil.getString(
3297                            request, "doAsUserLanguageId");
3298    
3299                    if (Validator.isNotNull(doAsUserLanguageId)) {
3300                            locale = LocaleUtil.fromLanguageId(doAsUserLanguageId);
3301    
3302                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3303                                    return locale;
3304                            }
3305                    }
3306    
3307                    HttpSession session = request.getSession(false);
3308    
3309                    if ((session != null) &&
3310                            session.getAttribute(Globals.LOCALE_KEY) != null) {
3311    
3312                            locale = (Locale)session.getAttribute(Globals.LOCALE_KEY);
3313    
3314                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3315                                    return locale;
3316                            }
3317                    }
3318    
3319                    // Get locale from the user
3320    
3321                    if (user == null) {
3322                            try {
3323                                    user = getUser(request);
3324                            }
3325                            catch (Exception e) {
3326                            }
3327                    }
3328    
3329                    if ((user != null) && !user.isDefaultUser()) {
3330                            Locale userLocale = getAvailableLocale(groupId, user.getLocale());
3331    
3332                            if (userLocale != null) {
3333                                    if (LanguageUtil.isAvailableLocale(groupId, userLocale)) {
3334                                            if (initialize) {
3335                                                    setLocale(request, response, userLocale);
3336                                            }
3337    
3338                                            return userLocale;
3339                                    }
3340                            }
3341                    }
3342    
3343                    // Get locale from the cookie
3344    
3345                    String languageId = CookieKeys.getCookie(
3346                            request, CookieKeys.GUEST_LANGUAGE_ID, false);
3347    
3348                    if (Validator.isNotNull(languageId)) {
3349                            Locale cookieLocale = getAvailableLocale(
3350                                    groupId, LocaleUtil.fromLanguageId(languageId));
3351    
3352                            if (cookieLocale != null) {
3353                                    if (LanguageUtil.isAvailableLocale(groupId, cookieLocale)) {
3354                                            if (initialize) {
3355                                                    setLocale(request, response, cookieLocale);
3356                                            }
3357    
3358                                            return cookieLocale;
3359                                    }
3360                            }
3361                    }
3362    
3363                    // Get locale from the request
3364    
3365                    if (PropsValues.LOCALE_DEFAULT_REQUEST) {
3366                            Enumeration<Locale> locales = request.getLocales();
3367    
3368                            while (locales.hasMoreElements()) {
3369                                    Locale requestLocale = getAvailableLocale(
3370                                            groupId, locales.nextElement());
3371    
3372                                    if (requestLocale != null) {
3373                                            if (LanguageUtil.isAvailableLocale(
3374                                                            groupId, requestLocale)) {
3375    
3376                                                    if (initialize) {
3377                                                            setLocale(request, response, requestLocale);
3378                                                    }
3379    
3380                                                    return requestLocale;
3381                                            }
3382                                    }
3383                            }
3384                    }
3385    
3386                    // Get locale from the group
3387    
3388                    if (groupId > 0) {
3389                            try {
3390                                    Group group = GroupLocalServiceUtil.getGroup(groupId);
3391    
3392                                    UnicodeProperties typeSettingsProperties =
3393                                            group.getTypeSettingsProperties();
3394    
3395                                    String defaultLanguageId = typeSettingsProperties.getProperty(
3396                                            "languageId");
3397    
3398                                    if (Validator.isNotNull(defaultLanguageId)) {
3399                                            locale = LocaleUtil.fromLanguageId(defaultLanguageId);
3400    
3401                                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3402                                                    if (initialize) {
3403                                                            setLocale(request, response, locale);
3404                                                    }
3405    
3406                                                    return locale;
3407                                            }
3408                                    }
3409                            }
3410                            catch (Exception e) {
3411                            }
3412                    }
3413    
3414                    // Get locale from the default user
3415    
3416                    Company company = null;
3417    
3418                    try {
3419                            company = getCompany(request);
3420                    }
3421                    catch (Exception e) {
3422                    }
3423    
3424                    if (company == null) {
3425                            return null;
3426                    }
3427    
3428                    User defaultUser = null;
3429    
3430                    try {
3431                            defaultUser = company.getDefaultUser();
3432                    }
3433                    catch (Exception e) {
3434                    }
3435    
3436                    if (defaultUser == null) {
3437                            return null;
3438                    }
3439    
3440                    Locale defaultUserLocale = getAvailableLocale(
3441                            groupId, defaultUser.getLocale());
3442    
3443                    if (defaultUserLocale != null) {
3444                            if (LanguageUtil.isAvailableLocale(groupId, defaultUserLocale)) {
3445                                    if (initialize) {
3446                                            setLocale(request, response, defaultUserLocale);
3447                                    }
3448    
3449                                    return defaultUserLocale;
3450                            }
3451                    }
3452    
3453                    try {
3454                            if (themeDisplay != null) {
3455                                    return themeDisplay.getSiteDefaultLocale();
3456                            }
3457                    }
3458                    catch (Exception e) {
3459                    }
3460    
3461                    try {
3462                            return getSiteDefaultLocale(groupId);
3463                    }
3464                    catch (Exception e) {
3465                            return LocaleUtil.getDefault();
3466                    }
3467            }
3468    
3469            @Override
3470            public Locale getLocale(PortletRequest portletRequest) {
3471                    return getLocale(getHttpServletRequest(portletRequest));
3472            }
3473    
3474            @Override
3475            public String getLocalizedFriendlyURL(
3476                            HttpServletRequest request, Layout layout, Locale locale,
3477                            Locale originalLocale)
3478                    throws Exception {
3479    
3480                    String contextPath = getPathContext();
3481    
3482                    String requestURI = request.getRequestURI();
3483    
3484                    if (Validator.isNotNull(contextPath) &&
3485                            requestURI.contains(contextPath)) {
3486    
3487                            requestURI = requestURI.substring(contextPath.length());
3488                    }
3489    
3490                    requestURI = StringUtil.replace(
3491                            requestURI, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3492    
3493                    String path = request.getPathInfo();
3494    
3495                    int x = path.indexOf(CharPool.SLASH, 1);
3496    
3497                    String layoutFriendlyURL = null;
3498    
3499                    if (originalLocale == null) {
3500                            if ((x != -1) && ((x + 1) != path.length())) {
3501                                    layoutFriendlyURL = path.substring(x);
3502                            }
3503    
3504                            int y = layoutFriendlyURL.indexOf(
3505                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
3506    
3507                            if (y != -1) {
3508                                    y = layoutFriendlyURL.indexOf(CharPool.SLASH, 3);
3509    
3510                                    if ((y != -1) && ((y + 1) != layoutFriendlyURL.length())) {
3511                                            layoutFriendlyURL = layoutFriendlyURL.substring(y);
3512                                    }
3513                            }
3514    
3515                            y = layoutFriendlyURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
3516    
3517                            if (y != -1) {
3518                                    layoutFriendlyURL = layoutFriendlyURL.substring(0, y);
3519                            }
3520                    }
3521                    else {
3522                            layoutFriendlyURL = layout.getFriendlyURL(originalLocale);
3523                    }
3524    
3525                    String friendlyURL = StringPool.SLASH;
3526    
3527                    if (requestURI.contains(layoutFriendlyURL)) {
3528                            requestURI = StringUtil.replaceFirst(
3529                                    requestURI, layoutFriendlyURL, layout.getFriendlyURL(locale));
3530    
3531                            friendlyURL = layout.getFriendlyURL(locale);
3532                    }
3533    
3534                    LayoutSet layoutSet = layout.getLayoutSet();
3535    
3536                    String virtualHostname = layoutSet.getVirtualHostname();
3537    
3538                    String portalURL = getPortalURL(request);
3539    
3540                    if (Validator.isNull(virtualHostname) ||
3541                            !portalURL.contains(virtualHostname)) {
3542    
3543                            friendlyURL = requestURI;
3544                    }
3545    
3546                    String i18nPath =
3547                            StringPool.SLASH +
3548                                    getI18nPathLanguageId(locale, LocaleUtil.toLanguageId(locale));
3549    
3550                    boolean appendI18nPath = true;
3551    
3552                    if ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 0) ||
3553                            ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
3554                             locale.equals(LocaleUtil.getDefault()))) {
3555    
3556                            appendI18nPath = false;
3557                    }
3558    
3559                    String localizedFriendlyURL = contextPath;
3560    
3561                    if (appendI18nPath) {
3562                            localizedFriendlyURL += i18nPath;
3563                    }
3564    
3565                    localizedFriendlyURL += friendlyURL;
3566    
3567                    String queryString = request.getQueryString();
3568    
3569                    if (Validator.isNotNull(queryString)) {
3570                            localizedFriendlyURL +=
3571                                    StringPool.QUESTION + request.getQueryString();
3572                    }
3573    
3574                    return localizedFriendlyURL;
3575            }
3576    
3577            @Override
3578            public String getMailId(String mx, String popPortletPrefix, Object... ids) {
3579                    StringBundler sb = new StringBundler(ids.length * 2 + 7);
3580    
3581                    sb.append(StringPool.LESS_THAN);
3582                    sb.append(popPortletPrefix);
3583    
3584                    if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
3585                            sb.append(StringPool.PERIOD);
3586                    }
3587    
3588                    for (int i = 0; i < ids.length; i++) {
3589                            Object id = ids[i];
3590    
3591                            if (i != 0) {
3592                                    sb.append(StringPool.PERIOD);
3593                            }
3594    
3595                            sb.append(id);
3596                    }
3597    
3598                    sb.append(StringPool.AT);
3599    
3600                    if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
3601                            sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
3602                            sb.append(StringPool.PERIOD);
3603                    }
3604    
3605                    sb.append(mx);
3606                    sb.append(StringPool.GREATER_THAN);
3607    
3608                    return sb.toString();
3609            }
3610    
3611            @Override
3612            public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
3613                    throws PortalException, SystemException {
3614    
3615                    return getServletURL(
3616                            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
3617            }
3618    
3619            @Override
3620            public String getNewPortletTitle(
3621                    String portletTitle, String oldScopeName, String newScopeName) {
3622    
3623                    if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
3624                            int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
3625    
3626                            portletTitle = portletTitle.substring(0, pos);
3627                    }
3628    
3629                    if (Validator.isNull(newScopeName)) {
3630                            return portletTitle;
3631                    }
3632    
3633                    StringBundler sb = new StringBundler(5);
3634    
3635                    sb.append(portletTitle);
3636                    sb.append(StringPool.SPACE);
3637                    sb.append(StringPool.OPEN_PARENTHESIS);
3638                    sb.append(newScopeName);
3639                    sb.append(StringPool.CLOSE_PARENTHESIS);
3640    
3641                    return sb.toString();
3642            }
3643    
3644            @Override
3645            public HttpServletRequest getOriginalServletRequest(
3646                    HttpServletRequest request) {
3647    
3648                    List<PersistentHttpServletRequestWrapper>
3649                            persistentHttpServletRequestWrappers =
3650                                    new ArrayList<PersistentHttpServletRequestWrapper>();
3651    
3652                    HttpServletRequest originalRequest = request;
3653    
3654                    while (originalRequest.getClass().getName().startsWith(
3655                                            "com.liferay.")) {
3656    
3657                            if (originalRequest instanceof
3658                                            PersistentHttpServletRequestWrapper) {
3659    
3660                                    PersistentHttpServletRequestWrapper
3661                                            persistentHttpServletRequestWrapper =
3662                                                    (PersistentHttpServletRequestWrapper)originalRequest;
3663    
3664                                    persistentHttpServletRequestWrappers.add(
3665                                            persistentHttpServletRequestWrapper.clone());
3666                            }
3667    
3668                            // Get original request so that portlets inside portlets render
3669                            // properly
3670    
3671                            HttpServletRequestWrapper httpServletRequestWrapper =
3672                                    (HttpServletRequestWrapper)originalRequest;
3673    
3674                            originalRequest =
3675                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
3676                    }
3677    
3678                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
3679                                    i--) {
3680    
3681                            HttpServletRequestWrapper httpServletRequestWrapper =
3682                                    persistentHttpServletRequestWrappers.get(i);
3683    
3684                            httpServletRequestWrapper.setRequest(originalRequest);
3685    
3686                            originalRequest = httpServletRequestWrapper;
3687                    }
3688    
3689                    return originalRequest;
3690            }
3691    
3692            /**
3693             * @deprecated As of 6.2.0 renamed to #getSiteGroupId(groupId)
3694             */
3695            @Override
3696            public long getParentGroupId(long groupId)
3697                    throws PortalException, SystemException {
3698    
3699                    return getSiteGroupId(groupId);
3700            }
3701    
3702            @Override
3703            public String getPathContext() {
3704                    return _pathContext;
3705            }
3706    
3707            @Override
3708            public String getPathContext(HttpServletRequest request) {
3709                    return getPathContext(request.getContextPath());
3710            }
3711    
3712            @Override
3713            public String getPathContext(PortletRequest portletRequest) {
3714                    return getPathContext(portletRequest.getContextPath());
3715            }
3716    
3717            @Override
3718            public String getPathContext(String contextPath) {
3719                    return _pathProxy.concat(ContextPathUtil.getContextPath(contextPath));
3720            }
3721    
3722            @Override
3723            public String getPathFriendlyURLPrivateGroup() {
3724                    return _pathFriendlyURLPrivateGroup;
3725            }
3726    
3727            @Override
3728            public String getPathFriendlyURLPrivateUser() {
3729                    return _pathFriendlyURLPrivateUser;
3730            }
3731    
3732            @Override
3733            public String getPathFriendlyURLPublic() {
3734                    return _pathFriendlyURLPublic;
3735            }
3736    
3737            @Override
3738            public String getPathImage() {
3739                    return _pathImage;
3740            }
3741    
3742            @Override
3743            public String getPathMain() {
3744                    return _pathMain;
3745            }
3746    
3747            @Override
3748            public String getPathModule() {
3749                    return _pathModule;
3750            }
3751    
3752            @Override
3753            public String getPathProxy() {
3754                    return _pathProxy;
3755            }
3756    
3757            @Override
3758            public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
3759                    if (Validator.isNull(friendlyURL)) {
3760                            return LayoutConstants.DEFAULT_PLID;
3761                    }
3762    
3763                    String[] urlParts = friendlyURL.split("\\/", 4);
3764    
3765                    if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
3766                            (urlParts.length != 4)) {
3767    
3768                            return LayoutConstants.DEFAULT_PLID;
3769                    }
3770    
3771                    boolean privateLayout = true;
3772    
3773                    String urlPrefix = StringPool.SLASH + urlParts[1];
3774    
3775                    if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
3776                            privateLayout = false;
3777                    }
3778                    else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
3779                                     _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
3780    
3781                            privateLayout = true;
3782                    }
3783                    else {
3784                            return LayoutConstants.DEFAULT_PLID;
3785                    }
3786    
3787                    Group group = null;
3788    
3789                    try {
3790                            group = GroupLocalServiceUtil.getFriendlyURLGroup(
3791                                    companyId, StringPool.SLASH + urlParts[2]);
3792                    }
3793                    catch (Exception e) {
3794                    }
3795    
3796                    if (group == null) {
3797                            return LayoutConstants.DEFAULT_PLID;
3798                    }
3799    
3800                    Layout layout = null;
3801    
3802                    try {
3803                            String layoutFriendlyURL = null;
3804    
3805                            if (urlParts.length == 4) {
3806                                    layoutFriendlyURL = StringPool.SLASH + urlParts[3];
3807    
3808                                    layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3809                                            group.getGroupId(), privateLayout, layoutFriendlyURL);
3810                            }
3811                            else {
3812                                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3813                                            group.getGroupId(), privateLayout,
3814                                            LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
3815    
3816                                    if (!layouts.isEmpty()) {
3817                                            layout = layouts.get(0);
3818                                    }
3819                                    else {
3820                                            return LayoutConstants.DEFAULT_PLID;
3821                                    }
3822                            }
3823    
3824                            return layout.getPlid();
3825                    }
3826                    catch (Exception e) {
3827                    }
3828    
3829                    return LayoutConstants.DEFAULT_PLID;
3830            }
3831    
3832            @Override
3833            public long getPlidFromPortletId(
3834                            long groupId, boolean privateLayout, String portletId)
3835                    throws PortalException, SystemException {
3836    
3837                    long plid = LayoutConstants.DEFAULT_PLID;
3838    
3839                    StringBundler sb = new StringBundler(5);
3840    
3841                    sb.append(groupId);
3842                    sb.append(StringPool.SPACE);
3843                    sb.append(privateLayout);
3844                    sb.append(StringPool.SPACE);
3845                    sb.append(portletId);
3846    
3847                    String key = sb.toString();
3848    
3849                    Long plidObj = _plidToPortletIdMap.get(key);
3850    
3851                    if (plidObj == null) {
3852                            plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
3853    
3854                            if (plid != LayoutConstants.DEFAULT_PLID) {
3855                                    _plidToPortletIdMap.put(key, plid);
3856                            }
3857                    }
3858                    else {
3859                            plid = plidObj.longValue();
3860    
3861                            boolean validPlid = false;
3862    
3863                            try {
3864                                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
3865    
3866                                    LayoutTypePortlet layoutTypePortlet =
3867                                            (LayoutTypePortlet)layout.getLayoutType();
3868    
3869                                    if (layoutTypePortlet.hasDefaultScopePortletId(
3870                                                    groupId, portletId)) {
3871    
3872                                            validPlid = true;
3873                                    }
3874                            }
3875                            catch (Exception e) {
3876                            }
3877    
3878                            if (!validPlid) {
3879                                    _plidToPortletIdMap.remove(key);
3880    
3881                                    plid = doGetPlidFromPortletId(
3882                                            groupId, privateLayout, portletId);
3883    
3884                                    if (plid != LayoutConstants.DEFAULT_PLID) {
3885                                            _plidToPortletIdMap.put(key, plid);
3886                                    }
3887                            }
3888                    }
3889    
3890                    return plid;
3891            }
3892    
3893            @Override
3894            public long getPlidFromPortletId(long groupId, String portletId)
3895                    throws PortalException, SystemException {
3896    
3897                    long plid = getPlidFromPortletId(groupId, false, portletId);
3898    
3899                    if (plid == LayoutConstants.DEFAULT_PLID) {
3900                            plid = getPlidFromPortletId(groupId, true, portletId);
3901                    }
3902    
3903                    if (plid == LayoutConstants.DEFAULT_PLID) {
3904                            if (_log.isDebugEnabled()) {
3905                                    _log.debug(
3906                                            "Portlet " + portletId +
3907                                                    " does not exist on a page in group " + groupId);
3908                            }
3909                    }
3910    
3911                    return plid;
3912            }
3913    
3914            @Override
3915            public String getPortalLibDir() {
3916                    return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3917            }
3918    
3919            /**
3920             * @deprecated As of 6.1.0, replaced by {@link #getPortalPort(boolean)}
3921             */
3922            @Override
3923            public int getPortalPort() {
3924                    return _portalPort.get();
3925            }
3926    
3927            @Override
3928            public int getPortalPort(boolean secure) {
3929                    if (secure) {
3930                            return _securePortalPort.get();
3931                    }
3932                    else {
3933                            return _portalPort.get();
3934                    }
3935            }
3936    
3937            @Override
3938            public Properties getPortalProperties() {
3939                    return PropsUtil.getProperties();
3940            }
3941    
3942            @Override
3943            public String getPortalURL(HttpServletRequest request) {
3944                    return getPortalURL(request, isSecure(request));
3945            }
3946    
3947            @Override
3948            public String getPortalURL(HttpServletRequest request, boolean secure) {
3949                    return getPortalURL(
3950                            request.getServerName(), request.getServerPort(), secure);
3951            }
3952    
3953            @Override
3954            public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3955                    throws PortalException, SystemException {
3956    
3957                    String serverName = themeDisplay.getServerName();
3958    
3959                    if (layout == null) {
3960                            layout = themeDisplay.getLayout();
3961                    }
3962    
3963                    if (layout != null) {
3964                            return getPortalURL(layout.getLayoutSet(), themeDisplay);
3965                    }
3966    
3967                    return getPortalURL(
3968                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
3969            }
3970    
3971            @Override
3972            public String getPortalURL(LayoutSet layoutSet, ThemeDisplay themeDisplay) {
3973                    String serverName = themeDisplay.getServerName();
3974    
3975                    String virtualHostname = layoutSet.getVirtualHostname();
3976    
3977                    if (Validator.isNotNull(virtualHostname)) {
3978                            String domain = themeDisplay.getPortalDomain();
3979    
3980                            if (domain.startsWith(virtualHostname)) {
3981                                    serverName = virtualHostname;
3982                            }
3983                    }
3984    
3985                    return getPortalURL(
3986                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
3987            }
3988    
3989            @Override
3990            public String getPortalURL(PortletRequest portletRequest) {
3991                    return getPortalURL(portletRequest, portletRequest.isSecure());
3992            }
3993    
3994            @Override
3995            public String getPortalURL(PortletRequest portletRequest, boolean secure) {
3996                    return getPortalURL(
3997                            portletRequest.getServerName(), portletRequest.getServerPort(),
3998                            secure);
3999            }
4000    
4001            @Override
4002            public String getPortalURL(
4003                    String serverName, int serverPort, boolean secure) {
4004    
4005                    StringBundler sb = new StringBundler();
4006    
4007                    boolean https =
4008                            (secure ||
4009                             StringUtil.equalsIgnoreCase(
4010                                    Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL));
4011    
4012                    if (https) {
4013                            sb.append(Http.HTTPS_WITH_SLASH);
4014                    }
4015                    else {
4016                            sb.append(Http.HTTP_WITH_SLASH);
4017                    }
4018    
4019                    if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
4020                            sb.append(serverName);
4021                    }
4022                    else {
4023                            sb.append(PropsValues.WEB_SERVER_HOST);
4024                    }
4025    
4026                    if (!https) {
4027                            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
4028                                    if ((serverPort != -1) && (serverPort != Http.HTTP_PORT) &&
4029                                            (serverPort != Http.HTTPS_PORT)) {
4030    
4031                                            sb.append(StringPool.COLON);
4032                                            sb.append(serverPort);
4033                                    }
4034                            }
4035                            else {
4036                                    if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
4037                                            sb.append(StringPool.COLON);
4038                                            sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
4039                                    }
4040                            }
4041                    }
4042                    else {
4043                            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
4044                                    if ((serverPort != -1) && (serverPort != Http.HTTP_PORT) &&
4045                                            (serverPort != Http.HTTPS_PORT)) {
4046    
4047                                            sb.append(StringPool.COLON);
4048                                            sb.append(serverPort);
4049                                    }
4050                            }
4051                            else {
4052                                    if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
4053                                            sb.append(StringPool.COLON);
4054                                            sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
4055                                    }
4056                            }
4057                    }
4058    
4059                    return sb.toString();
4060            }
4061    
4062            @Override
4063            public String getPortalURL(ThemeDisplay themeDisplay)
4064                    throws PortalException, SystemException {
4065    
4066                    return getPortalURL((Layout)null, themeDisplay);
4067            }
4068    
4069            @Override
4070            public String getPortalWebDir() {
4071                    return PropsValues.LIFERAY_WEB_PORTAL_DIR;
4072            }
4073    
4074            /**
4075             * @deprecated As of 6.2.0, replaced by {@link
4076             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelist}
4077             */
4078            @Override
4079            public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
4080                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
4081            }
4082    
4083            /**
4084             * @deprecated As of 6.2.0, replaced by {@link
4085             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelistActions}
4086             */
4087            @Override
4088            public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
4089                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
4090            }
4091    
4092            /**
4093             * @deprecated As of 6.1.0, replaced by {@link
4094             *             #getPortletBreadcrumbs(HttpServletRequest)}
4095             */
4096            @Override
4097            public List<BreadcrumbEntry> getPortletBreadcrumbList(
4098                    HttpServletRequest request) {
4099    
4100                    return getPortletBreadcrumbs(request);
4101            }
4102    
4103            @Override
4104            public List<BreadcrumbEntry> getPortletBreadcrumbs(
4105                    HttpServletRequest request) {
4106    
4107                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4108                            WebKeys.THEME_DISPLAY);
4109    
4110                    PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
4111    
4112                    String name = WebKeys.PORTLET_BREADCRUMBS;
4113    
4114                    String portletName = portletDisplay.getPortletName();
4115    
4116                    if (Validator.isNotNull(portletDisplay.getId()) &&
4117                            !portletName.equals(PortletKeys.BREADCRUMB) &&
4118                            !portletDisplay.isFocused()) {
4119    
4120                            name = name.concat(
4121                                    StringPool.UNDERLINE.concat(portletDisplay.getId()));
4122                    }
4123    
4124                    return (List<BreadcrumbEntry>)request.getAttribute(name);
4125            }
4126    
4127            @Override
4128            public PortletConfig getPortletConfig(
4129                            long companyId, String portletId, ServletContext servletContext)
4130                    throws PortletException, SystemException {
4131    
4132                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
4133                            companyId, portletId);
4134    
4135                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
4136                            portlet, servletContext);
4137    
4138                    return invokerPortlet.getPortletConfig();
4139            }
4140    
4141            @Override
4142            public String getPortletDescription(
4143                    Portlet portlet, ServletContext servletContext, Locale locale) {
4144    
4145                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4146                            portlet, servletContext);
4147    
4148                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4149    
4150                    String portletDescription = ResourceBundleUtil.getString(
4151                            resourceBundle,
4152                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4153                                    StringPool.PERIOD).concat(portlet.getRootPortletId()));
4154    
4155                    if (Validator.isNull(portletDescription)) {
4156                            portletDescription = ResourceBundleUtil.getString(
4157                                    resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
4158                    }
4159    
4160                    return portletDescription;
4161            }
4162    
4163            @Override
4164            public String getPortletDescription(Portlet portlet, User user) {
4165                    return getPortletDescription(portlet.getPortletId(), user);
4166            }
4167    
4168            @Override
4169            public String getPortletDescription(String portletId, Locale locale) {
4170                    return LanguageUtil.get(
4171                            locale,
4172                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4173                                    StringPool.PERIOD).concat(portletId));
4174            }
4175    
4176            @Override
4177            public String getPortletDescription(String portletId, String languageId) {
4178                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4179    
4180                    return getPortletDescription(portletId, locale);
4181            }
4182    
4183            @Override
4184            public String getPortletDescription(String portletId, User user) {
4185                    return LanguageUtil.get(
4186                            user.getLocale(),
4187                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4188                                    StringPool.PERIOD).concat(portletId));
4189            }
4190    
4191            public LayoutQueryStringComposite
4192                    getPortletFriendlyURLMapperLayoutQueryStringComposite(
4193                            long groupId, boolean privateLayout, String url,
4194                            Map<String, String[]> params, Map<String, Object> requestContext)
4195                    throws PortalException, SystemException {
4196    
4197                    boolean foundFriendlyURLMapper = false;
4198    
4199                    String friendlyURL = url;
4200                    String queryString = StringPool.BLANK;
4201    
4202                    List<Portlet> portlets =
4203                            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
4204    
4205                    for (Portlet portlet : portlets) {
4206                            FriendlyURLMapper friendlyURLMapper =
4207                                    portlet.getFriendlyURLMapperInstance();
4208    
4209                            if (url.endsWith(
4210                                            StringPool.SLASH + friendlyURLMapper.getMapping())) {
4211    
4212                                    url += StringPool.SLASH;
4213                            }
4214    
4215                            int pos = -1;
4216    
4217                            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4218                                    pos = url.indexOf(
4219                                            FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
4220                                                    StringPool.SLASH);
4221                            }
4222                            else {
4223                                    pos = url.indexOf(
4224                                            StringPool.SLASH + friendlyURLMapper.getMapping() +
4225                                                    StringPool.SLASH);
4226                            }
4227    
4228                            if (pos != -1) {
4229                                    foundFriendlyURLMapper = true;
4230    
4231                                    friendlyURL = url.substring(0, pos);
4232    
4233                                    InheritableMap<String, String[]> actualParams =
4234                                            new InheritableMap<String, String[]>();
4235    
4236                                    if (params != null) {
4237                                            actualParams.setParentMap(params);
4238                                    }
4239    
4240                                    Map<String, String> prpIdentifiers =
4241                                            new HashMap<String, String>();
4242    
4243                                    Set<PublicRenderParameter> publicRenderParameters =
4244                                            portlet.getPublicRenderParameters();
4245    
4246                                    for (PublicRenderParameter publicRenderParameter :
4247                                                    publicRenderParameters) {
4248    
4249                                            QName qName = publicRenderParameter.getQName();
4250    
4251                                            String publicRenderParameterIdentifier =
4252                                                    qName.getLocalPart();
4253                                            String publicRenderParameterName =
4254                                                    PortletQNameUtil.getPublicRenderParameterName(qName);
4255    
4256                                            prpIdentifiers.put(
4257                                                    publicRenderParameterIdentifier,
4258                                                    publicRenderParameterName);
4259                                    }
4260    
4261                                    FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
4262    
4263                                    if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4264                                            friendlyURLMapper.populateParams(
4265                                                    url.substring(pos + 2), actualParams, requestContext);
4266                                    }
4267                                    else {
4268                                            friendlyURLMapper.populateParams(
4269                                                    url.substring(pos), actualParams, requestContext);
4270                                    }
4271    
4272                                    queryString =
4273                                            StringPool.AMPERSAND +
4274                                                    HttpUtil.parameterMapToString(actualParams, false);
4275    
4276                                    break;
4277                            }
4278                    }
4279    
4280                    if (!foundFriendlyURLMapper) {
4281                            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
4282    
4283                            if (x != -1) {
4284                                    int y = url.indexOf(CharPool.SLASH, x + 3);
4285    
4286                                    if (y == -1) {
4287                                            y = url.length();
4288                                    }
4289    
4290                                    String ppid = url.substring(x + 3, y);
4291    
4292                                    if (Validator.isNotNull(ppid)) {
4293                                            friendlyURL = url.substring(0, x);
4294    
4295                                            Map<String, String[]> actualParams = null;
4296    
4297                                            if (params != null) {
4298                                                    actualParams = new HashMap<String, String[]>(params);
4299                                            }
4300                                            else {
4301                                                    actualParams = new HashMap<String, String[]>();
4302                                            }
4303    
4304                                            actualParams.put("p_p_id", new String[] {ppid});
4305                                            actualParams.put("p_p_lifecycle", new String[] {"0"});
4306                                            actualParams.put(
4307                                                    "p_p_state",
4308                                                    new String[] {WindowState.MAXIMIZED.toString()});
4309                                            actualParams.put(
4310                                                    "p_p_mode", new String[] {PortletMode.VIEW.toString()});
4311    
4312                                            queryString =
4313                                                    StringPool.AMPERSAND +
4314                                                            HttpUtil.parameterMapToString(actualParams, false);
4315                                    }
4316                            }
4317                    }
4318    
4319                    friendlyURL = StringUtil.replace(
4320                            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
4321    
4322                    if (friendlyURL.endsWith(StringPool.SLASH)) {
4323                            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
4324                    }
4325    
4326                    Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
4327                            groupId, privateLayout, friendlyURL);
4328    
4329                    return new LayoutQueryStringComposite(layout, friendlyURL, queryString);
4330            }
4331    
4332            @Override
4333            public String getPortletId(HttpServletRequest request) {
4334                    LiferayPortletConfig liferayPortletConfig =
4335                            (LiferayPortletConfig)request.getAttribute(
4336                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4337    
4338                    if (liferayPortletConfig != null) {
4339                            return liferayPortletConfig.getPortletId();
4340                    }
4341                    else {
4342                            return null;
4343                    }
4344            }
4345    
4346            @Override
4347            public String getPortletId(PortletRequest portletRequest) {
4348                    LiferayPortletConfig liferayPortletConfig =
4349                            (LiferayPortletConfig)portletRequest.getAttribute(
4350                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4351    
4352                    if (liferayPortletConfig != null) {
4353                            return liferayPortletConfig.getPortletId();
4354                    }
4355                    else {
4356                            return null;
4357                    }
4358            }
4359    
4360            @Override
4361            public String getPortletLongTitle(Portlet portlet, Locale locale) {
4362                    return getPortletLongTitle(portlet.getPortletId(), locale);
4363            }
4364    
4365            @Override
4366            public String getPortletLongTitle(
4367                    Portlet portlet, ServletContext servletContext, Locale locale) {
4368    
4369                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4370                            portlet, servletContext);
4371    
4372                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4373    
4374                    try {
4375                            String portletLongTitle = resourceBundle.getString(
4376                                    JavaConstants.JAVAX_PORTLET_LONG_TITLE);
4377    
4378                            if (portletLongTitle.startsWith(
4379                                            JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
4380    
4381                                    portletLongTitle = getPortletTitle(
4382                                            portlet, servletContext, locale);
4383                            }
4384    
4385                            return portletLongTitle;
4386                    }
4387                    catch (Exception e) {
4388                            return getPortletTitle(portlet, servletContext, locale);
4389                    }
4390            }
4391    
4392            @Override
4393            public String getPortletLongTitle(Portlet portlet, String languageId) {
4394                    return getPortletLongTitle(portlet.getPortletId(), languageId);
4395            }
4396    
4397            @Override
4398            public String getPortletLongTitle(Portlet portlet, User user) {
4399                    return getPortletLongTitle(portlet.getPortletId(), user);
4400            }
4401    
4402            @Override
4403            public String getPortletLongTitle(String portletId, Locale locale) {
4404                    String portletLongTitle = LanguageUtil.get(
4405                            locale,
4406                            JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
4407                                    StringPool.PERIOD).concat(portletId),
4408                            StringPool.BLANK);
4409    
4410                    if (Validator.isNull(portletLongTitle)) {
4411                            portletLongTitle = getPortletTitle(portletId, locale);
4412                    }
4413    
4414                    return portletLongTitle;
4415            }
4416    
4417            @Override
4418            public String getPortletLongTitle(String portletId, String languageId) {
4419                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4420    
4421                    return getPortletLongTitle(portletId, locale);
4422            }
4423    
4424            @Override
4425            public String getPortletLongTitle(String portletId, User user) {
4426                    return getPortletLongTitle(portletId, user.getLocale());
4427            }
4428    
4429            @Override
4430            public String getPortletNamespace(String portletId) {
4431                    return StringPool.UNDERLINE.concat(portletId).concat(
4432                            StringPool.UNDERLINE);
4433            }
4434    
4435            @Override
4436            public String getPortletTitle(Portlet portlet, Locale locale) {
4437                    return getPortletTitle(portlet.getPortletId(), locale);
4438            }
4439    
4440            @Override
4441            public String getPortletTitle(
4442                    Portlet portlet, ServletContext servletContext, Locale locale) {
4443    
4444                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4445                            portlet, servletContext);
4446    
4447                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4448    
4449                    String portletTitle = ResourceBundleUtil.getString(
4450                            resourceBundle,
4451                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4452                                    portlet.getRootPortletId()));
4453    
4454                    if (Validator.isNull(portletTitle)) {
4455                            portletTitle = ResourceBundleUtil.getString(
4456                                    resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4457                    }
4458    
4459                    return portletTitle;
4460            }
4461    
4462            @Override
4463            public String getPortletTitle(Portlet portlet, String languageId) {
4464                    return getPortletTitle(portlet.getPortletId(), languageId);
4465            }
4466    
4467            @Override
4468            public String getPortletTitle(Portlet portlet, User user) {
4469                    return getPortletTitle(portlet.getPortletId(), user);
4470            }
4471    
4472            @Override
4473            public String getPortletTitle(RenderRequest renderRequest) {
4474                    String portletId = (String)renderRequest.getAttribute(
4475                            WebKeys.PORTLET_ID);
4476    
4477                    Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);
4478    
4479                    HttpServletRequest request = getHttpServletRequest(renderRequest);
4480    
4481                    ServletContext servletContext = (ServletContext)request.getAttribute(
4482                            WebKeys.CTX);
4483    
4484                    Locale locale = renderRequest.getLocale();
4485    
4486                    return getPortletTitle(portlet, servletContext, locale);
4487            }
4488    
4489            @Override
4490            public String getPortletTitle(RenderResponse renderResponse) {
4491                    PortletResponseImpl portletResponseImpl =
4492                            PortletResponseImpl.getPortletResponseImpl(renderResponse);
4493    
4494                    return ((RenderResponseImpl)portletResponseImpl).getTitle();
4495            }
4496    
4497            @Override
4498            public String getPortletTitle(String portletId, Locale locale) {
4499                    return LanguageUtil.get(
4500                            locale,
4501                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4502                                    portletId));
4503            }
4504    
4505            @Override
4506            public String getPortletTitle(String portletId, String languageId) {
4507                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4508    
4509                    return getPortletTitle(portletId, locale);
4510            }
4511    
4512            @Override
4513            public String getPortletTitle(String portletId, User user) {
4514                    return LanguageUtil.get(
4515                            user.getLocale(),
4516                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4517                                    portletId));
4518            }
4519    
4520            @Override
4521            public String getPortletXmlFileName() throws SystemException {
4522                    if (PrefsPropsUtil.getBoolean(
4523                                    PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
4524                                    PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
4525    
4526                            return PORTLET_XML_FILE_NAME_CUSTOM;
4527                    }
4528                    else {
4529                            return PORTLET_XML_FILE_NAME_STANDARD;
4530                    }
4531            }
4532    
4533            @Override
4534            public PortletPreferences getPreferences(HttpServletRequest request) {
4535                    RenderRequest renderRequest = (RenderRequest)request.getAttribute(
4536                            JavaConstants.JAVAX_PORTLET_REQUEST);
4537    
4538                    PortletPreferences portletPreferences = null;
4539    
4540                    if (renderRequest != null) {
4541                            PortletPreferencesWrapper portletPreferencesWrapper =
4542                                    (PortletPreferencesWrapper)renderRequest.getPreferences();
4543    
4544                            portletPreferences =
4545                                    portletPreferencesWrapper.getPortletPreferencesImpl();
4546                    }
4547    
4548                    return portletPreferences;
4549            }
4550    
4551            @Override
4552            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
4553                    PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
4554    
4555                    return portletBag.getPreferencesValidatorInstance();
4556            }
4557    
4558            @Override
4559            public String getRelativeHomeURL(HttpServletRequest request)
4560                    throws PortalException, SystemException {
4561    
4562                    Company company = getCompany(request);
4563    
4564                    String homeURL = company.getHomeURL();
4565    
4566                    if (Validator.isNull(homeURL)) {
4567                            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
4568                    }
4569    
4570                    return homeURL;
4571            }
4572    
4573            @Override
4574            public long getScopeGroupId(HttpServletRequest request)
4575                    throws PortalException, SystemException {
4576    
4577                    String portletId = getPortletId(request);
4578    
4579                    return getScopeGroupId(request, portletId);
4580            }
4581    
4582            @Override
4583            public long getScopeGroupId(HttpServletRequest request, String portletId)
4584                    throws PortalException, SystemException {
4585    
4586                    return getScopeGroupId(request, portletId, false);
4587            }
4588    
4589            @Override
4590            public long getScopeGroupId(
4591                            HttpServletRequest request, String portletId,
4592                            boolean checkStagingGroup)
4593                    throws PortalException, SystemException {
4594    
4595                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4596    
4597                    long scopeGroupId = 0;
4598    
4599                    if (layout != null) {
4600                            Group group = layout.getGroup();
4601    
4602                            long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
4603    
4604                            if (doAsGroupId <= 0) {
4605                                    HttpServletRequest originalRequest = getOriginalServletRequest(
4606                                            request);
4607    
4608                                    doAsGroupId = ParamUtil.getLong(originalRequest, "doAsGroupId");
4609                            }
4610    
4611                            Group doAsGroup = null;
4612    
4613                            if (doAsGroupId > 0) {
4614                                    doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
4615                            }
4616    
4617                            if (group.isControlPanel()) {
4618                                    if (doAsGroup == null) {
4619                                            doAsGroupId = getDefaultScopeGroupId(group.getCompanyId());
4620                                    }
4621    
4622                                    if (doAsGroupId > 0) {
4623                                            scopeGroupId = doAsGroupId;
4624                                    }
4625    
4626                                    group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
4627    
4628                                    if ((group != null) && group.hasStagingGroup()) {
4629                                            try {
4630                                                    Group stagingGroup = group.getStagingGroup();
4631    
4632                                                    scopeGroupId = stagingGroup.getGroupId();
4633                                            }
4634                                            catch (Exception e) {
4635                                            }
4636                                    }
4637                            }
4638                            else if (doAsGroup != null) {
4639                                    scopeGroupId = doAsGroupId;
4640                            }
4641    
4642                            if ((portletId != null) && (group != null) &&
4643                                    (group.isStaged() || group.isStagingGroup())) {
4644    
4645                                    Group liveGroup = group;
4646    
4647                                    if (group.isStagingGroup()) {
4648                                            liveGroup = group.getLiveGroup();
4649                                    }
4650    
4651                                    if (liveGroup.isStaged() &&
4652                                            !liveGroup.isStagedPortlet(portletId)) {
4653    
4654                                            Layout liveGroupLayout =
4655                                                    LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
4656                                                                    layout.getUuid(), liveGroup.getGroupId(),
4657                                                                    layout.isPrivateLayout());
4658    
4659                                            if ((liveGroupLayout != null) &&
4660                                                    liveGroupLayout.hasScopeGroup()) {
4661    
4662                                                    scopeGroupId = getScopeGroupId(
4663                                                            liveGroupLayout, portletId);
4664                                            }
4665                                            else if (checkStagingGroup &&
4666                                                             !liveGroup.isStagedRemotely()) {
4667    
4668                                                    Group stagingGroup = liveGroup.getStagingGroup();
4669    
4670                                                    scopeGroupId = stagingGroup.getGroupId();
4671                                            }
4672                                            else {
4673                                                    scopeGroupId = liveGroup.getGroupId();
4674                                            }
4675                                    }
4676                            }
4677                    }
4678    
4679                    if (scopeGroupId <= 0) {
4680                            scopeGroupId = getScopeGroupId(layout, portletId);
4681                    }
4682    
4683                    return scopeGroupId;
4684            }
4685    
4686            @Override
4687            public long getScopeGroupId(Layout layout) {
4688                    if (layout == null) {
4689                            return 0;
4690                    }
4691                    else {
4692                            return layout.getGroupId();
4693                    }
4694            }
4695    
4696            @Override
4697            public long getScopeGroupId(Layout layout, String portletId) {
4698                    if (layout == null) {
4699                            return 0;
4700                    }
4701    
4702                    if (Validator.isNull(portletId)) {
4703                            return layout.getGroupId();
4704                    }
4705    
4706                    try {
4707                            PortletPreferences portletSetup =
4708                                    PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
4709                                            layout, portletId);
4710    
4711                            String scopeType = GetterUtil.getString(
4712                                    portletSetup.getValue("lfrScopeType", null));
4713    
4714                            if (Validator.isNull(scopeType)) {
4715                                    return layout.getGroupId();
4716                            }
4717    
4718                            if (scopeType.equals("company")) {
4719                                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4720                                            layout.getCompanyId());
4721    
4722                                    return companyGroup.getGroupId();
4723                            }
4724    
4725                            String scopeLayoutUuid = GetterUtil.getString(
4726                                    portletSetup.getValue("lfrScopeLayoutUuid", null));
4727    
4728                            Layout scopeLayout =
4729                                    LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
4730                                            scopeLayoutUuid, layout.getGroupId(),
4731                                            layout.isPrivateLayout());
4732    
4733                            Group scopeGroup = scopeLayout.getScopeGroup();
4734    
4735                            return scopeGroup.getGroupId();
4736                    }
4737                    catch (Exception e) {
4738                            return layout.getGroupId();
4739                    }
4740            }
4741    
4742            @Override
4743            public long getScopeGroupId(long plid) {
4744                    Layout layout = null;
4745    
4746                    try {
4747                            layout = LayoutLocalServiceUtil.getLayout(plid);
4748                    }
4749                    catch (Exception e) {
4750                    }
4751    
4752                    return getScopeGroupId(layout);
4753            }
4754    
4755            @Override
4756            public long getScopeGroupId(PortletRequest portletRequest)
4757                    throws PortalException, SystemException {
4758    
4759                    return getScopeGroupId(getHttpServletRequest(portletRequest));
4760            }
4761    
4762            @Override
4763            public User getSelectedUser(HttpServletRequest request)
4764                    throws PortalException, SystemException {
4765    
4766                    return getSelectedUser(request, true);
4767            }
4768    
4769            @Override
4770            public User getSelectedUser(
4771                            HttpServletRequest request, boolean checkPermission)
4772                    throws PortalException, SystemException {
4773    
4774                    long userId = ParamUtil.getLong(request, "p_u_i_d");
4775    
4776                    User user = null;
4777    
4778                    try {
4779                            if (checkPermission) {
4780                                    user = UserServiceUtil.getUserById(userId);
4781                            }
4782                            else {
4783                                    user = UserLocalServiceUtil.getUserById(userId);
4784                            }
4785                    }
4786                    catch (NoSuchUserException nsue) {
4787                    }
4788    
4789                    return user;
4790            }
4791    
4792            @Override
4793            public User getSelectedUser(PortletRequest portletRequest)
4794                    throws PortalException, SystemException {
4795    
4796                    return getSelectedUser(portletRequest, true);
4797            }
4798    
4799            @Override
4800            public User getSelectedUser(
4801                            PortletRequest portletRequest, boolean checkPermission)
4802                    throws PortalException, SystemException {
4803    
4804                    return getSelectedUser(
4805                            getHttpServletRequest(portletRequest), checkPermission);
4806            }
4807    
4808            @Override
4809            public String getServletContextName() {
4810                    return _servletContextName;
4811            }
4812    
4813            @Override
4814            public Map<String, List<Portlet>> getSiteAdministrationCategoriesMap(
4815                            HttpServletRequest request)
4816                    throws SystemException {
4817    
4818                    return getCategoriesMap(
4819                            request, WebKeys.SITE_ADMINISTRATION_CATEGORIES_MAP,
4820                            PortletCategoryKeys.SITE_ADMINISTRATION_ALL);
4821            }
4822    
4823            @Override
4824            public long[] getSharedContentSiteGroupIds(
4825                            long companyId, long groupId, long userId)
4826                    throws PortalException, SystemException {
4827    
4828                    List<Group> groups = new UniqueList<Group>();
4829    
4830                    Group siteGroup = doGetCurrentSiteGroup(groupId);
4831    
4832                    if (siteGroup != null) {
4833    
4834                            // Current site
4835    
4836                            groups.add(siteGroup);
4837    
4838                            // Descendant sites
4839    
4840                            groups.addAll(siteGroup.getChildren(true));
4841    
4842                            // Layout scopes
4843    
4844                            groups.addAll(
4845                                    GroupLocalServiceUtil.getGroups(
4846                                            siteGroup.getCompanyId(), Layout.class.getName(),
4847                                            siteGroup.getGroupId()));
4848                    }
4849    
4850                    // Administered sites
4851    
4852                    if (PrefsPropsUtil.getBoolean(
4853                                    companyId,
4854                                    PropsKeys.
4855                                            SITES_CONTENT_SHARING_THROUGH_ADMINISTRATORS_ENABLED)) {
4856    
4857                            LinkedHashMap<String, Object> groupParams =
4858                                    new LinkedHashMap<String, Object>();
4859    
4860                            groupParams.put("site", Boolean.TRUE);
4861                            groupParams.put("usersGroups", userId);
4862    
4863                            groups.addAll(
4864                                    GroupLocalServiceUtil.search(
4865                                            companyId, null, null, groupParams, QueryUtil.ALL_POS,
4866                                            QueryUtil.ALL_POS, null));
4867                    }
4868    
4869                    // Ancestor sites and global site
4870    
4871                    int sitesContentSharingWithChildrenEnabled = PrefsPropsUtil.getInteger(
4872                            companyId, PropsKeys.SITES_CONTENT_SHARING_WITH_CHILDREN_ENABLED);
4873    
4874                    if (sitesContentSharingWithChildrenEnabled !=
4875                                    Sites.CONTENT_SHARING_WITH_CHILDREN_DISABLED) {
4876    
4877                            groups.addAll(doGetAncestorSiteGroups(groupId, true));
4878                    }
4879    
4880                    long[] groupIds = new long[groups.size()];
4881    
4882                    for (int i = 0; i < groups.size(); i++) {
4883                            Group group = groups.get(i);
4884    
4885                            groupIds[i] = group.getGroupId();
4886                    }
4887    
4888                    return groupIds;
4889            }
4890    
4891            @Override
4892            public PortletURL getSiteAdministrationURL(
4893                            HttpServletRequest request, ThemeDisplay themeDisplay)
4894                    throws SystemException {
4895    
4896                    Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4897    
4898                    if (portlet == null) {
4899                            return null;
4900                    }
4901    
4902                    return getSiteAdministrationURL(
4903                            request, themeDisplay, portlet.getPortletId());
4904            }
4905    
4906            @Override
4907            public PortletURL getSiteAdministrationURL(
4908                    HttpServletRequest request, ThemeDisplay themeDisplay,
4909                    String portletId) {
4910    
4911                    LiferayPortletURL siteAdministrationURL = PortletURLFactoryUtil.create(
4912                            request, portletId, themeDisplay.getPlid(),
4913                            PortletRequest.RENDER_PHASE);
4914    
4915                    siteAdministrationURL.setControlPanelCategory(
4916                            PortletCategoryKeys.SITES);
4917                    siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4918                    siteAdministrationURL.setParameter(
4919                            "redirect", themeDisplay.getURLCurrent());
4920    
4921                    return siteAdministrationURL;
4922            }
4923    
4924            @Override
4925            public PortletURL getSiteAdministrationURL(
4926                            PortletResponse portletResponse, ThemeDisplay themeDisplay)
4927                    throws SystemException {
4928    
4929                    Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4930    
4931                    if (portlet == null) {
4932                            return null;
4933                    }
4934    
4935                    return getSiteAdministrationURL(
4936                            portletResponse, themeDisplay, portlet.getPortletId());
4937            }
4938    
4939            @Override
4940            public PortletURL getSiteAdministrationURL(
4941                    PortletResponse portletResponse, ThemeDisplay themeDisplay,
4942                    String portletName) {
4943    
4944                    LiferayPortletResponse liferayPortletResponse =
4945                            (LiferayPortletResponse)portletResponse;
4946    
4947                    LiferayPortletURL siteAdministrationURL =
4948                            liferayPortletResponse.createRenderURL(portletName);
4949    
4950                    siteAdministrationURL.setControlPanelCategory(
4951                            PortletCategoryKeys.SITES);
4952                    siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4953                    siteAdministrationURL.setParameter(
4954                            "redirect", themeDisplay.getURLCurrent());
4955    
4956                    return siteAdministrationURL;
4957            }
4958    
4959            @Override
4960            public long[] getSiteAndCompanyGroupIds(long groupId)
4961                    throws PortalException, SystemException {
4962    
4963                    Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
4964    
4965                    if (scopeGroup.isCompany()) {
4966                            return new long[] {groupId};
4967                    }
4968    
4969                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4970                            scopeGroup.getCompanyId());
4971    
4972                    if (scopeGroup.isLayout()) {
4973                            return new long[] {
4974                                    groupId, scopeGroup.getParentGroupId(),
4975                                    companyGroup.getGroupId()
4976                            };
4977                    }
4978                    else if (scopeGroup.isLayoutSetPrototype() ||
4979                                     scopeGroup.isOrganization() || scopeGroup.isRegularSite() ||
4980                                     scopeGroup.isUser()) {
4981    
4982                            return new long[] {groupId, companyGroup.getGroupId()};
4983                    }
4984                    else {
4985                            return new long[] {companyGroup.getGroupId()};
4986                    }
4987            }
4988    
4989            @Override
4990            public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
4991                    throws PortalException, SystemException {
4992    
4993                    return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
4994            }
4995    
4996            @Override
4997            public Locale getSiteDefaultLocale(long groupId)
4998                    throws PortalException, SystemException {
4999    
5000                    if (groupId <= 0) {
5001                            return LocaleUtil.getDefault();
5002                    }
5003    
5004                    Group group = GroupLocalServiceUtil.getGroup(groupId);
5005    
5006                    Group liveGroup = group;
5007    
5008                    if (group.isStagingGroup()) {
5009                            liveGroup = group.getLiveGroup();
5010                    }
5011    
5012                    if (LanguageUtil.isInheritLocales(liveGroup.getGroupId())) {
5013                            return LocaleUtil.getDefault();
5014                    }
5015    
5016                    UnicodeProperties typeSettingsProperties =
5017                            liveGroup.getTypeSettingsProperties();
5018    
5019                    User defaultUser = UserLocalServiceUtil.getDefaultUser(
5020                            group.getCompanyId());
5021    
5022                    String languageId = GetterUtil.getString(
5023                            typeSettingsProperties.getProperty("languageId"),
5024                            defaultUser.getLanguageId());
5025    
5026                    return LocaleUtil.fromLanguageId(languageId);
5027            }
5028    
5029            @Override
5030            public long getSiteGroupId(long groupId)
5031                    throws PortalException, SystemException {
5032    
5033                    if (groupId <= 0) {
5034                            return 0;
5035                    }
5036    
5037                    Group group = GroupLocalServiceUtil.getGroup(groupId);
5038    
5039                    long siteGroupId = groupId;
5040    
5041                    if (group.isLayout()) {
5042                            siteGroupId = group.getParentGroupId();
5043                    }
5044    
5045                    return siteGroupId;
5046            }
5047    
5048            @Override
5049            public String getSiteLoginURL(ThemeDisplay themeDisplay)
5050                    throws PortalException, SystemException {
5051    
5052                    if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
5053                            return null;
5054                    }
5055    
5056                    List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
5057    
5058                    if (layouts == null) {
5059                            return null;
5060                    }
5061    
5062                    for (Layout layout : layouts) {
5063                            String friendlyURL = layout.getFriendlyURL(
5064                                    themeDisplay.getLocale());
5065    
5066                            if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
5067                                    if (themeDisplay.getLayout() == null) {
5068                                            break;
5069                                    }
5070    
5071                                    String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
5072                                            layout.getLayoutSet(), themeDisplay);
5073    
5074                                    return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
5075                            }
5076                    }
5077    
5078                    return null;
5079            }
5080    
5081            @Override
5082            public String getStaticResourceURL(HttpServletRequest request, String uri) {
5083                    return getStaticResourceURL(request, uri, null, 0);
5084            }
5085    
5086            @Override
5087            public String getStaticResourceURL(
5088                    HttpServletRequest request, String uri, long timestamp) {
5089    
5090                    return getStaticResourceURL(request, uri, null, timestamp);
5091            }
5092    
5093            @Override
5094            public String getStaticResourceURL(
5095                    HttpServletRequest request, String uri, String queryString) {
5096    
5097                    return getStaticResourceURL(request, uri, queryString, 0);
5098            }
5099    
5100            @Override
5101            public String getStaticResourceURL(
5102                    HttpServletRequest request, String uri, String queryString,
5103                    long timestamp) {
5104    
5105                    if (uri.indexOf(CharPool.QUESTION) != -1) {
5106                            return uri;
5107                    }
5108    
5109                    if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
5110                            uri = uri.substring(1);
5111                    }
5112    
5113                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5114                            WebKeys.THEME_DISPLAY);
5115    
5116                    Theme theme = themeDisplay.getTheme();
5117                    ColorScheme colorScheme = themeDisplay.getColorScheme();
5118    
5119                    Map<String, String[]> parameterMap = null;
5120    
5121                    if (Validator.isNotNull(queryString)) {
5122                            parameterMap = HttpUtil.getParameterMap(queryString);
5123                    }
5124    
5125                    StringBundler sb = new StringBundler();
5126    
5127                    // URI
5128    
5129                    sb.append(uri);
5130                    sb.append(StringPool.QUESTION);
5131    
5132                    // Browser id
5133    
5134                    if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
5135                            sb.append("&browserId=");
5136                            sb.append(BrowserSnifferUtil.getBrowserId(request));
5137                    }
5138    
5139                    // Theme and color scheme
5140    
5141                    if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
5142                            ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
5143    
5144                            sb.append("&themeId=");
5145                            sb.append(HttpUtil.encodeURL(theme.getThemeId()));
5146                    }
5147    
5148                    if (uri.endsWith(".jsp") &&
5149                            ((parameterMap == null) ||
5150                             !parameterMap.containsKey("colorSchemeId"))) {
5151    
5152                            sb.append("&colorSchemeId=");
5153                            sb.append(HttpUtil.encodeURL(colorScheme.getColorSchemeId()));
5154                    }
5155    
5156                    // Minifier
5157    
5158                    if ((parameterMap == null) ||
5159                            !parameterMap.containsKey("minifierType")) {
5160    
5161                            String minifierType = StringPool.BLANK;
5162    
5163                            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
5164                                    (uri.endsWith(".jsp") && uri.contains("/css/"))) {
5165    
5166                                    if (themeDisplay.isThemeCssFastLoad()) {
5167                                            minifierType = "css";
5168                                    }
5169                            }
5170                            else if (themeDisplay.isThemeJsFastLoad()) {
5171                                    minifierType = "js";
5172                            }
5173    
5174                            if (Validator.isNotNull(minifierType)) {
5175                                    sb.append("&minifierType=");
5176                                    sb.append(minifierType);
5177                            }
5178                    }
5179    
5180                    // Query string
5181    
5182                    if (Validator.isNotNull(queryString)) {
5183                            if (!queryString.startsWith(StringPool.AMPERSAND)) {
5184                                    sb.append(StringPool.AMPERSAND);
5185                            }
5186    
5187                            sb.append(queryString);
5188                    }
5189    
5190                    // Language id
5191    
5192                    sb.append("&languageId=");
5193                    sb.append(themeDisplay.getLanguageId());
5194    
5195                    // Build number
5196    
5197                    sb.append("&b=");
5198                    sb.append(ReleaseInfo.getBuildNumber());
5199    
5200                    // Timestamp
5201    
5202                    if ((parameterMap == null) || !parameterMap.containsKey("t")) {
5203                            if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
5204                                    ServletContext servletContext =
5205                                            (ServletContext)request.getAttribute(WebKeys.CTX);
5206    
5207                                    timestamp = ServletContextUtil.getLastModified(
5208                                            servletContext, uri, true);
5209                            }
5210    
5211                            if (timestamp == 0) {
5212                                    timestamp = theme.getTimestamp();
5213                            }
5214    
5215                            sb.append("&t=");
5216                            sb.append(timestamp);
5217                    }
5218    
5219                    String url = sb.toString();
5220    
5221                    url = StringUtil.replace(url, "?&", StringPool.QUESTION);
5222    
5223                    return url;
5224            }
5225    
5226            @Override
5227            public String getStrutsAction(HttpServletRequest request) {
5228                    String strutsAction = ParamUtil.getString(request, "struts_action");
5229    
5230                    if (Validator.isNotNull(strutsAction)) {
5231    
5232                            // This method should only return a Struts action if you're dealing
5233                            // with a regular HTTP servlet request, not a portlet HTTP servlet
5234                            // request.
5235    
5236                            return StringPool.BLANK;
5237                    }
5238    
5239                    return getPortletParam(request, "struts_action");
5240            }
5241    
5242            @Override
5243            public String[] getSystemGroups() {
5244                    return _allSystemGroups;
5245            }
5246    
5247            @Override
5248            public String[] getSystemOrganizationRoles() {
5249                    return _allSystemOrganizationRoles;
5250            }
5251    
5252            @Override
5253            public String[] getSystemRoles() {
5254                    return _allSystemRoles;
5255            }
5256    
5257            @Override
5258            public String[] getSystemSiteRoles() {
5259                    return _allSystemSiteRoles;
5260            }
5261    
5262            @Override
5263            public String getUniqueElementId(
5264                    HttpServletRequest request, String namespace, String elementId) {
5265    
5266                    String uniqueElementId = elementId;
5267    
5268                    Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
5269                            WebKeys.UNIQUE_ELEMENT_IDS);
5270    
5271                    if (uniqueElementIds == null) {
5272                            uniqueElementIds = new ConcurrentHashSet<String>();
5273    
5274                            request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
5275                    }
5276                    else {
5277                            int i = 1;
5278    
5279                            while (uniqueElementIds.contains(
5280                                                    namespace.concat(uniqueElementId))) {
5281    
5282                                    if (Validator.isNull(elementId) ||
5283                                            elementId.endsWith(StringPool.UNDERLINE)) {
5284    
5285                                            uniqueElementId = elementId.concat(String.valueOf(i));
5286                                    }
5287                                    else {
5288                                            uniqueElementId =
5289                                                    elementId.concat(StringPool.UNDERLINE).concat(
5290                                                            String.valueOf(i));
5291                                    }
5292    
5293                                    i++;
5294                            }
5295                    }
5296    
5297                    uniqueElementIds.add(namespace.concat(uniqueElementId));
5298    
5299                    return uniqueElementId;
5300            }
5301    
5302            @Override
5303            public String getUniqueElementId(
5304                    PortletRequest request, String namespace, String elementId) {
5305    
5306                    return getUniqueElementId(
5307                            getHttpServletRequest(request), namespace, elementId);
5308            }
5309    
5310            @Override
5311            public UploadPortletRequest getUploadPortletRequest(
5312                    PortletRequest portletRequest) {
5313    
5314                    PortletRequestImpl portletRequestImpl =
5315                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
5316    
5317                    DynamicServletRequest dynamicRequest =
5318                            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
5319    
5320                    HttpServletRequestWrapper requestWrapper =
5321                            (HttpServletRequestWrapper)dynamicRequest.getRequest();
5322    
5323                    UploadServletRequest uploadServletRequest = getUploadServletRequest(
5324                            requestWrapper);
5325    
5326                    return new UploadPortletRequestImpl(
5327                            uploadServletRequest, portletRequestImpl,
5328                            getPortletNamespace(portletRequestImpl.getPortletName()));
5329            }
5330    
5331            @Override
5332            public UploadServletRequest getUploadServletRequest(
5333                    HttpServletRequest request) {
5334    
5335                    List<PersistentHttpServletRequestWrapper>
5336                            persistentHttpServletRequestWrappers =
5337                                    new ArrayList<PersistentHttpServletRequestWrapper>();
5338    
5339                    HttpServletRequest currentRequest = request;
5340    
5341                    while (currentRequest instanceof HttpServletRequestWrapper) {
5342                            if (currentRequest instanceof UploadServletRequest) {
5343                                    return (UploadServletRequest)currentRequest;
5344                            }
5345    
5346                            Class<?> currentRequestClass = currentRequest.getClass();
5347    
5348                            String currentRequestClassName = currentRequestClass.getName();
5349    
5350                            if (!isUnwrapRequest(currentRequestClassName)) {
5351                                    break;
5352                            }
5353    
5354                            if (currentRequest instanceof
5355                                            PersistentHttpServletRequestWrapper) {
5356    
5357                                    PersistentHttpServletRequestWrapper
5358                                            persistentHttpServletRequestWrapper =
5359                                                    (PersistentHttpServletRequestWrapper)currentRequest;
5360    
5361                                    persistentHttpServletRequestWrappers.add(
5362                                            persistentHttpServletRequestWrapper.clone());
5363                            }
5364    
5365                            HttpServletRequestWrapper httpServletRequestWrapper =
5366                                    (HttpServletRequestWrapper)currentRequest;
5367    
5368                            currentRequest =
5369                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
5370                    }
5371    
5372                    if (ServerDetector.isWebLogic()) {
5373                            currentRequest = new NonSerializableObjectRequestWrapper(
5374                                    currentRequest);
5375                    }
5376    
5377                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5378                                    i--) {
5379    
5380                            HttpServletRequestWrapper httpServletRequestWrapper =
5381                                    persistentHttpServletRequestWrappers.get(i);
5382    
5383                            httpServletRequestWrapper.setRequest(currentRequest);
5384    
5385                            currentRequest = httpServletRequestWrapper;
5386                    }
5387    
5388                    return new UploadServletRequestImpl(currentRequest);
5389            }
5390    
5391            @Override
5392            public Date getUptime() {
5393                    return _upTime;
5394            }
5395    
5396            @Override
5397            public String getURLWithSessionId(String url, String sessionId) {
5398                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5399                            return url;
5400                    }
5401    
5402                    if (Validator.isNull(url)) {
5403                            return url;
5404                    }
5405    
5406                    // LEP-4787
5407    
5408                    int x = url.indexOf(CharPool.SEMICOLON);
5409    
5410                    if (x != -1) {
5411                            return url;
5412                    }
5413    
5414                    x = url.indexOf(CharPool.QUESTION);
5415    
5416                    if (x != -1) {
5417                            StringBundler sb = new StringBundler(4);
5418    
5419                            sb.append(url.substring(0, x));
5420                            sb.append(JSESSIONID);
5421                            sb.append(sessionId);
5422                            sb.append(url.substring(x));
5423    
5424                            return sb.toString();
5425                    }
5426    
5427                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
5428                    // http://www.abc.com/;jsessionid=XYZ does work.
5429    
5430                    x = url.indexOf(StringPool.DOUBLE_SLASH);
5431    
5432                    StringBundler sb = new StringBundler(4);
5433    
5434                    sb.append(url);
5435    
5436                    if (x != -1) {
5437                            int y = url.lastIndexOf(CharPool.SLASH);
5438    
5439                            if ((x + 1) == y) {
5440                                    sb.append(StringPool.SLASH);
5441                            }
5442                    }
5443    
5444                    sb.append(JSESSIONID);
5445                    sb.append(sessionId);
5446    
5447                    return sb.toString();
5448            }
5449    
5450            @Override
5451            public User getUser(HttpServletRequest request)
5452                    throws PortalException, SystemException {
5453    
5454                    User user = (User)request.getAttribute(WebKeys.USER);
5455    
5456                    if (user != null) {
5457                            return user;
5458                    }
5459    
5460                    long userId = getUserId(request);
5461    
5462                    if (userId <= 0) {
5463    
5464                            // Portlet WARs may have the correct remote user and not have the
5465                            // correct user id because the user id is saved in the session and
5466                            // may not be accessible by the portlet WAR's session. This behavior
5467                            // is inconsistent across different application servers.
5468    
5469                            String remoteUser = request.getRemoteUser();
5470    
5471                            if ((remoteUser == null) && !PropsValues.PORTAL_JAAS_ENABLE) {
5472                                    HttpSession session = request.getSession();
5473    
5474                                    remoteUser = (String)session.getAttribute("j_remoteuser");
5475                            }
5476    
5477                            if (remoteUser == null) {
5478                                    return null;
5479                            }
5480    
5481                            if (PropsValues.PORTAL_JAAS_ENABLE) {
5482                                    long companyId = getCompanyId(request);
5483    
5484                                    try {
5485                                            userId = JAASHelper.getJaasUserId(companyId, remoteUser);
5486                                    }
5487                                    catch (Exception e) {
5488                                            if (_log.isWarnEnabled()) {
5489                                                    _log.warn(e, e);
5490                                            }
5491                                    }
5492                            }
5493                            else {
5494                                    userId = GetterUtil.getLong(remoteUser);
5495                            }
5496                    }
5497    
5498                    if (userId > 0) {
5499                            user = UserLocalServiceUtil.getUserById(userId);
5500    
5501                            request.setAttribute(WebKeys.USER, user);
5502                    }
5503    
5504                    Cookie[] cookies = request.getCookies();
5505    
5506                    if (cookies != null) {
5507                            for (Cookie cookie : cookies) {
5508                                    String cookieName = cookie.getName();
5509    
5510                                    if (cookieName.startsWith(
5511                                                    CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5512    
5513                                            user.addRemotePreference(
5514                                                    new CookieRemotePreference(cookie));
5515                                    }
5516                            }
5517                    }
5518    
5519                    return user;
5520            }
5521    
5522            @Override
5523            public User getUser(PortletRequest portletRequest)
5524                    throws PortalException, SystemException {
5525    
5526                    return getUser(getHttpServletRequest(portletRequest));
5527            }
5528    
5529            @Override
5530            public String getUserEmailAddress(long userId) throws SystemException {
5531                    try {
5532                            User user = UserLocalServiceUtil.getUserById(userId);
5533    
5534                            return user.getEmailAddress();
5535                    }
5536                    catch (PortalException pe) {
5537                            return StringPool.BLANK;
5538                    }
5539            }
5540    
5541            @Override
5542            public long getUserId(HttpServletRequest request) {
5543                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5544    
5545                    if (userIdObj != null) {
5546                            return userIdObj.longValue();
5547                    }
5548    
5549                    String path = GetterUtil.getString(request.getPathInfo());
5550                    String strutsAction = getStrutsAction(request);
5551                    String actionName = getPortletParam(request, "actionName");
5552    
5553                    boolean alwaysAllowDoAsUser = false;
5554    
5555                    if (path.equals("/portal/session_click") ||
5556                            strutsAction.equals("/document_library/edit_file_entry") ||
5557                            strutsAction.equals("/document_library_display/edit_file_entry") ||
5558                            strutsAction.equals("/image_gallery_display/edit_file_entry") ||
5559                            strutsAction.equals("/image_gallery_display/edit_image") ||
5560                            strutsAction.equals("/wiki/edit_page_attachment") ||
5561                            strutsAction.equals("/wiki_admin/edit_page_attachment") ||
5562                            strutsAction.equals("/wiki_display/edit_page_attachment") ||
5563                            actionName.equals("addFile")) {
5564    
5565                            try {
5566                                    alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5567                            }
5568                            catch (Exception e) {
5569                                    _log.error(e, e);
5570                            }
5571                    }
5572    
5573                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5574                             PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5575                            alwaysAllowDoAsUser) {
5576    
5577                            String doAsUserIdString = ParamUtil.getString(
5578                                    request, "doAsUserId");
5579    
5580                            try {
5581                                    long doAsUserId = getDoAsUserId(
5582                                            request, doAsUserIdString, alwaysAllowDoAsUser);
5583    
5584                                    if (doAsUserId > 0) {
5585                                            if (_log.isDebugEnabled()) {
5586                                                    _log.debug("Impersonating user " + doAsUserId);
5587                                            }
5588    
5589                                            return doAsUserId;
5590                                    }
5591                            }
5592                            catch (Exception e) {
5593                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
5594                            }
5595                    }
5596    
5597                    HttpSession session = request.getSession();
5598    
5599                    userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5600    
5601                    if (userIdObj != null) {
5602                            request.setAttribute(WebKeys.USER_ID, userIdObj);
5603    
5604                            return userIdObj.longValue();
5605                    }
5606                    else {
5607                            return 0;
5608                    }
5609            }
5610    
5611            @Override
5612            public long getUserId(PortletRequest portletRequest) {
5613                    return getUserId(getHttpServletRequest(portletRequest));
5614            }
5615    
5616            @Override
5617            public String getUserName(BaseModel<?> baseModel) {
5618                    long userId = 0;
5619                    String userName = StringPool.BLANK;
5620    
5621                    if (baseModel instanceof AuditedModel) {
5622                            AuditedModel auditedModel = (AuditedModel)baseModel;
5623    
5624                            userId = auditedModel.getUserId();
5625                            userName = auditedModel.getUserName();
5626                    }
5627                    else {
5628                            userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5629                            userName = BeanPropertiesUtil.getStringSilent(
5630                                    baseModel, "userName");
5631                    }
5632    
5633                    if (userId == 0) {
5634                            return StringPool.BLANK;
5635                    }
5636    
5637                    if (baseModel.isEscapedModel()) {
5638                            userName = HtmlUtil.unescape(userName);
5639                    }
5640    
5641                    userName = getUserName(userId, userName);
5642    
5643                    if (baseModel.isEscapedModel()) {
5644                            userName = HtmlUtil.escape(userName);
5645                    }
5646    
5647                    return userName;
5648            }
5649    
5650            @Override
5651            public String getUserName(long userId, String defaultUserName) {
5652                    return getUserName(
5653                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5654            }
5655    
5656            @Override
5657            public String getUserName(
5658                    long userId, String defaultUserName, HttpServletRequest request) {
5659    
5660                    return getUserName(
5661                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5662            }
5663    
5664            @Override
5665            public String getUserName(
5666                    long userId, String defaultUserName, String userAttribute) {
5667    
5668                    return getUserName(userId, defaultUserName, userAttribute, null);
5669            }
5670    
5671            @Override
5672            public String getUserName(
5673                    long userId, String defaultUserName, String userAttribute,
5674                    HttpServletRequest request) {
5675    
5676                    String userName = defaultUserName;
5677    
5678                    try {
5679                            User user = UserLocalServiceUtil.getUserById(userId);
5680    
5681                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5682                                    userName = user.getFullName();
5683                            }
5684                            else {
5685                                    userName = user.getScreenName();
5686                            }
5687    
5688                            if (request != null) {
5689                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5690    
5691                                    PortletURL portletURL = PortletURLFactoryUtil.create(
5692                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
5693                                            PortletRequest.RENDER_PHASE);
5694    
5695                                    portletURL.setParameter(
5696                                            "struts_action", "/directory/view_user");
5697                                    portletURL.setParameter(
5698                                            "p_u_i_d", String.valueOf(user.getUserId()));
5699                                    portletURL.setPortletMode(PortletMode.VIEW);
5700                                    portletURL.setWindowState(WindowState.MAXIMIZED);
5701    
5702                                    userName =
5703                                            "<a href=\"" + portletURL.toString() + "\">" +
5704                                                    HtmlUtil.escape(userName) + "</a>";
5705                            }
5706                    }
5707                    catch (Exception e) {
5708                    }
5709    
5710                    return userName;
5711            }
5712    
5713            @Override
5714            public String getUserPassword(HttpServletRequest request) {
5715                    request = getOriginalServletRequest(request);
5716    
5717                    HttpSession session = request.getSession();
5718    
5719                    return getUserPassword(session);
5720            }
5721    
5722            @Override
5723            public String getUserPassword(HttpSession session) {
5724                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5725            }
5726    
5727            @Override
5728            public String getUserPassword(PortletRequest portletRequest) {
5729                    return getUserPassword(getHttpServletRequest(portletRequest));
5730            }
5731    
5732            @Override
5733            public String getUserValue(long userId, String param, String defaultValue)
5734                    throws SystemException {
5735    
5736                    if (Validator.isNotNull(defaultValue)) {
5737                            return defaultValue;
5738                    }
5739    
5740                    try {
5741                            User user = UserLocalServiceUtil.getUserById(userId);
5742    
5743                            return BeanPropertiesUtil.getString(user, param, defaultValue);
5744                    }
5745                    catch (PortalException pe) {
5746                            return StringPool.BLANK;
5747                    }
5748            }
5749    
5750            @Override
5751            public String getValidPortalDomain(long companyId, String domain) {
5752                    if (_validPortalDomainCheckDisabled) {
5753                            return domain;
5754                    }
5755    
5756                    for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
5757                            if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
5758                                    StringUtil.wildcardMatches(
5759                                            domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
5760                                            CharPool.PERCENT, false)) {
5761    
5762                                    return domain;
5763                            }
5764                    }
5765    
5766                    if (_log.isWarnEnabled()) {
5767                            _log.warn(
5768                                    "Set the property \"" + PropsKeys.VIRTUAL_HOSTS_VALID_HOSTS +
5769                                            "\" in portal.properties to allow \"" + domain +
5770                                                    "\" as a domain");
5771                    }
5772    
5773                    try {
5774                            Company company = CompanyLocalServiceUtil.getCompanyById(
5775                                    getDefaultCompanyId());
5776    
5777                            return company.getVirtualHostname();
5778                    }
5779                    catch (Exception e) {
5780                            _log.error("Unable to load default portal instance", e);
5781                    }
5782    
5783                    return _LOCALHOST;
5784            }
5785    
5786            @Override
5787            public long getValidUserId(long companyId, long userId)
5788                    throws PortalException, SystemException {
5789    
5790                    User user = UserLocalServiceUtil.fetchUser(userId);
5791    
5792                    if (user == null) {
5793                            return UserLocalServiceUtil.getDefaultUserId(companyId);
5794                    }
5795    
5796                    if (user.getCompanyId() == companyId) {
5797                            return user.getUserId();
5798                    }
5799    
5800                    return userId;
5801            }
5802    
5803            @Override
5804            public String getVirtualLayoutActualURL(
5805                            long groupId, boolean privateLayout, String mainPath,
5806                            String friendlyURL, Map<String, String[]> params,
5807                            Map<String, Object> requestContext)
5808                    throws PortalException, SystemException {
5809    
5810                    // Group friendly URL
5811    
5812                    String groupFriendlyURL = null;
5813    
5814                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5815    
5816                    if (pos != -1) {
5817                            groupFriendlyURL = friendlyURL.substring(2, pos);
5818                    }
5819    
5820                    if (Validator.isNull(groupFriendlyURL)) {
5821                            return mainPath;
5822                    }
5823    
5824                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5825                            "request");
5826    
5827                    long companyId = PortalInstances.getCompanyId(request);
5828    
5829                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5830                            companyId, groupFriendlyURL);
5831    
5832                    if (group == null) {
5833                            return mainPath;
5834                    }
5835    
5836                    // Layout friendly URL
5837    
5838                    String layoutFriendlyURL = null;
5839    
5840                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5841                            layoutFriendlyURL = friendlyURL.substring(pos);
5842                    }
5843    
5844                    if (Validator.isNull(layoutFriendlyURL)) {
5845                            return mainPath;
5846                    }
5847    
5848                    String actualURL = getActualURL(
5849                            group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
5850                            params, requestContext);
5851    
5852                    return HttpUtil.addParameter(
5853                            HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
5854                            groupId);
5855            }
5856    
5857            @Override
5858            public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5859                            boolean privateLayout, String friendlyURL,
5860                            Map<String, String[]> params, Map<String, Object> requestContext)
5861                    throws PortalException, SystemException {
5862    
5863                    // Group friendly URL
5864    
5865                    String groupFriendlyURL = null;
5866    
5867                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5868    
5869                    if (pos != -1) {
5870                            groupFriendlyURL = friendlyURL.substring(2, pos);
5871                    }
5872    
5873                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5874                            "request");
5875    
5876                    long companyId = PortalInstances.getCompanyId(request);
5877    
5878                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5879                            companyId, groupFriendlyURL);
5880    
5881                    // Layout friendly URL
5882    
5883                    String layoutFriendlyURL = null;
5884    
5885                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5886                            layoutFriendlyURL = friendlyURL.substring(pos);
5887                    }
5888    
5889                    LayoutQueryStringComposite layoutQueryStringComposite =
5890                            getActualLayoutQueryStringComposite(
5891                                    group.getGroupId(), privateLayout, layoutFriendlyURL, params,
5892                                    requestContext);
5893    
5894                    return new LayoutFriendlyURLComposite(
5895                            layoutQueryStringComposite.getLayout(), layoutFriendlyURL);
5896            }
5897    
5898            @Override
5899            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5900                    throws PortalException, SystemException {
5901    
5902                    return getServletURL(
5903                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5904            }
5905    
5906            @Override
5907            public void initCustomSQL() {
5908                    _customSqlKeys = new String[] {
5909                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5910                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5911                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5912                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5913                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5914                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5915                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5916                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5917                                    "BOOKMARKSENTRY$]",
5918                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5919                                    "BOOKMARKSFOLDER$]",
5920                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
5921                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5922                                    "DLFILEENTRY$]",
5923                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5924                                    "DLFOLDER$]",
5925                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.JOURNAL.MODEL." +
5926                                    "JOURNALFOLDER$]",
5927                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5928                                    "MBMESSAGE$]",
5929                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5930                                    "MBTHREAD$]",
5931                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
5932                            "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5933                            "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5934                            "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5935                            "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5936                            "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5937                            "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5938                            "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5939                            "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5940                            "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5941                            "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5942                            "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5943                            "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5944                            "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5945                            "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5946                    };
5947    
5948                    DB db = DBFactoryUtil.getDB();
5949    
5950                    Object[] customSqlValues = new Object[] {
5951                            getClassNameId(Group.class), getClassNameId(Layout.class),
5952                            getClassNameId(Organization.class), getClassNameId(Role.class),
5953                            getClassNameId(User.class), getClassNameId(UserGroup.class),
5954                            getClassNameId(BlogsEntry.class),
5955                            getClassNameId(BookmarksEntry.class),
5956                            getClassNameId(BookmarksFolder.class),
5957                            getClassNameId(CalEvent.class), getClassNameId(DLFileEntry.class),
5958                            getClassNameId(DLFolder.class), getClassNameId(JournalFolder.class),
5959                            getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
5960                            getClassNameId(WikiPage.class), ResourceConstants.SCOPE_COMPANY,
5961                            ResourceConstants.SCOPE_GROUP,
5962                            ResourceConstants.SCOPE_GROUP_TEMPLATE,
5963                            ResourceConstants.SCOPE_INDIVIDUAL,
5964                            SocialRelationConstants.TYPE_BI_COWORKER,
5965                            SocialRelationConstants.TYPE_BI_FRIEND,
5966                            SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5967                            SocialRelationConstants.TYPE_BI_SIBLING,
5968                            SocialRelationConstants.TYPE_BI_SPOUSE,
5969                            SocialRelationConstants.TYPE_UNI_CHILD,
5970                            SocialRelationConstants.TYPE_UNI_ENEMY,
5971                            SocialRelationConstants.TYPE_UNI_FOLLOWER,
5972                            SocialRelationConstants.TYPE_UNI_PARENT,
5973                            SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5974                            SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5975                            db.getTemplateTrue()
5976                    };
5977    
5978                    _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5979            }
5980    
5981            @Override
5982            public User initUser(HttpServletRequest request) throws Exception {
5983                    User user = null;
5984    
5985                    try {
5986                            user = getUser(request);
5987                    }
5988                    catch (NoSuchUserException nsue) {
5989                            if (_log.isWarnEnabled()) {
5990                                    _log.warn(nsue.getMessage());
5991                            }
5992    
5993                            long userId = getUserId(request);
5994    
5995                            if (userId > 0) {
5996                                    HttpSession session = request.getSession();
5997    
5998                                    session.invalidate();
5999                            }
6000    
6001                            throw nsue;
6002                    }
6003    
6004                    if (user != null) {
6005                            return user;
6006                    }
6007    
6008                    Company company = getCompany(request);
6009    
6010                    return company.getDefaultUser();
6011            }
6012    
6013            @Override
6014            public void invokeTaglibDiscussion(
6015                            PortletConfig portletConfig, ActionRequest actionRequest,
6016                            ActionResponse actionResponse)
6017                    throws Exception {
6018    
6019                    _editDiscussionAction.processAction(
6020                            null, null, portletConfig, actionRequest, actionResponse);
6021            }
6022    
6023            /**
6024             * @deprecated As of 6.2.0 with no direct replacement
6025             */
6026            @Override
6027            public boolean isAllowAddPortletDefaultResource(
6028                            HttpServletRequest request, Portlet portlet)
6029                    throws PortalException, SystemException {
6030    
6031                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6032                            WebKeys.THEME_DISPLAY);
6033    
6034                    Layout layout = themeDisplay.getLayout();
6035                    LayoutTypePortlet layoutTypePortlet =
6036                            themeDisplay.getLayoutTypePortlet();
6037    
6038                    String portletId = portlet.getPortletId();
6039    
6040                    Boolean renderPortletResource = (Boolean)request.getAttribute(
6041                            WebKeys.RENDER_PORTLET_RESOURCE);
6042    
6043                    if (renderPortletResource != null) {
6044                            boolean runtimePortlet = renderPortletResource.booleanValue();
6045    
6046                            if (runtimePortlet) {
6047                                    return true;
6048                            }
6049                    }
6050    
6051                    if (layout.isTypePanel() &&
6052                            isPanelSelectedPortlet(themeDisplay, portletId)) {
6053    
6054                            return true;
6055                    }
6056    
6057                    if (layout.isTypeControlPanel() &&
6058                            isControlPanelPortlet(portletId, themeDisplay)) {
6059    
6060                            return true;
6061                    }
6062    
6063                    if ((layoutTypePortlet != null) &&
6064                            layoutTypePortlet.hasPortletId(portletId)) {
6065    
6066                            return true;
6067                    }
6068    
6069                    if (themeDisplay.isSignedIn() &&
6070                            portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
6071    
6072                            PermissionChecker permissionChecker =
6073                                    themeDisplay.getPermissionChecker();
6074    
6075                            Group group = layout.getGroup();
6076    
6077                            if (group.isSite()) {
6078                                    if (LayoutPermissionUtil.contains(
6079                                                    permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
6080                                            LayoutPermissionUtil.contains(
6081                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
6082    
6083                                            return true;
6084                                    }
6085                            }
6086    
6087                            if (group.isCompany()) {
6088                                    if (permissionChecker.isCompanyAdmin()) {
6089                                            return true;
6090                                    }
6091                            }
6092                            else if (group.isLayoutPrototype()) {
6093                                    long layoutPrototypeId = group.getClassPK();
6094    
6095                                    if (LayoutPrototypePermissionUtil.contains(
6096                                                    permissionChecker, layoutPrototypeId,
6097                                                    ActionKeys.UPDATE)) {
6098    
6099                                            return true;
6100                                    }
6101                            }
6102                            else if (group.isLayoutSetPrototype()) {
6103                                    long layoutSetPrototypeId = group.getClassPK();
6104    
6105                                    if (LayoutSetPrototypePermissionUtil.contains(
6106                                                    permissionChecker, layoutSetPrototypeId,
6107                                                    ActionKeys.UPDATE)) {
6108    
6109                                            return true;
6110                                    }
6111                            }
6112                            else if (group.isOrganization()) {
6113                                    long organizationId = group.getOrganizationId();
6114    
6115                                    if (OrganizationPermissionUtil.contains(
6116                                                    permissionChecker, organizationId, ActionKeys.UPDATE)) {
6117    
6118                                            return true;
6119                                    }
6120                            }
6121                            else if (group.isUserGroup()) {
6122                                    long scopeGroupId = themeDisplay.getScopeGroupId();
6123    
6124                                    if (GroupPermissionUtil.contains(
6125                                                    permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
6126    
6127                                            return true;
6128                                    }
6129                            }
6130                            else if (group.isUser()) {
6131                                    return true;
6132                            }
6133                    }
6134    
6135                    if (!portlet.isAddDefaultResource()) {
6136                            return false;
6137                    }
6138    
6139                    if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
6140                            return true;
6141                    }
6142    
6143                    Set<String> whiteList =
6144                            AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
6145    
6146                    if (whiteList.contains(portletId)) {
6147                            return true;
6148                    }
6149    
6150                    String namespace = getPortletNamespace(portletId);
6151    
6152                    String strutsAction = ParamUtil.getString(
6153                            request, namespace + "struts_action");
6154    
6155                    if (Validator.isNull(strutsAction)) {
6156                            strutsAction = ParamUtil.getString(request, "struts_action");
6157                    }
6158    
6159                    Set<String> whitelistActions =
6160                            AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
6161    
6162                    if (whitelistActions.contains(strutsAction)) {
6163                            return true;
6164                    }
6165    
6166                    String requestPortletAuthenticationToken = ParamUtil.getString(
6167                            request, "p_p_auth");
6168    
6169                    if (Validator.isNull(requestPortletAuthenticationToken)) {
6170                            HttpServletRequest originalRequest = getOriginalServletRequest(
6171                                    request);
6172    
6173                            requestPortletAuthenticationToken = ParamUtil.getString(
6174                                    originalRequest, "p_p_auth");
6175                    }
6176    
6177                    if (Validator.isNotNull(requestPortletAuthenticationToken)) {
6178                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
6179                                    request, layout.getPlid(), portletId);
6180    
6181                            if (requestPortletAuthenticationToken.equals(
6182                                            actualPortletAuthenticationToken)) {
6183    
6184                                    return true;
6185                            }
6186                    }
6187    
6188                    return false;
6189            }
6190    
6191            @Override
6192            public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
6193                    throws PortalException, SystemException {
6194    
6195                    Company company = getCompany(request);
6196    
6197                    return isCDNDynamicResourcesEnabled(company.getCompanyId());
6198            }
6199    
6200            @Override
6201            public boolean isCDNDynamicResourcesEnabled(long companyId) {
6202                    try {
6203                            return PrefsPropsUtil.getBoolean(
6204                                    companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
6205                                    PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
6206                    }
6207                    catch (SystemException se) {
6208                    }
6209    
6210                    return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
6211            }
6212    
6213            /**
6214             * @deprecated As of 6.1.0, renamed to {@link #isGroupAdmin(User, long)}
6215             */
6216            @Override
6217            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
6218                    return isGroupAdmin(user, groupId);
6219            }
6220    
6221            /**
6222             * @deprecated As of 6.1.0, renamed to {@link #isGroupOwner(User, long)}
6223             */
6224            @Override
6225            public boolean isCommunityOwner(User user, long groupId) throws Exception {
6226                    return isGroupOwner(user, groupId);
6227            }
6228    
6229            @Override
6230            public boolean isCompanyAdmin(User user) throws Exception {
6231                    PermissionChecker permissionChecker =
6232                            PermissionCheckerFactoryUtil.create(user);
6233    
6234                    return permissionChecker.isCompanyAdmin();
6235            }
6236    
6237            @Override
6238            public boolean isCompanyControlPanelPortlet(
6239                            String portletId, String category, ThemeDisplay themeDisplay)
6240                    throws PortalException, SystemException {
6241    
6242                    PermissionChecker permissionChecker =
6243                            themeDisplay.getPermissionChecker();
6244    
6245                    if (permissionChecker.isCompanyAdmin()) {
6246                            return true;
6247                    }
6248    
6249                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6250                            themeDisplay.getCompanyId());
6251    
6252                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6253    
6254                    return isControlPanelPortlet(portletId, category, themeDisplay);
6255            }
6256    
6257            @Override
6258            public boolean isCompanyControlPanelPortlet(
6259                            String portletId, ThemeDisplay themeDisplay)
6260                    throws PortalException, SystemException {
6261    
6262                    PermissionChecker permissionChecker =
6263                            themeDisplay.getPermissionChecker();
6264    
6265                    if (permissionChecker.isCompanyAdmin()) {
6266                            return true;
6267                    }
6268    
6269                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6270                            themeDisplay.getCompanyId());
6271    
6272                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6273    
6274                    return isControlPanelPortlet(portletId, themeDisplay);
6275            }
6276    
6277            @Override
6278            public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
6279                    throws PortalException, SystemException {
6280    
6281                    PermissionChecker permissionChecker =
6282                            themeDisplay.getPermissionChecker();
6283    
6284                    if (permissionChecker.isCompanyAdmin()) {
6285                            return true;
6286                    }
6287    
6288                    long scopeGroupId = themeDisplay.getScopeGroupId();
6289    
6290                    try {
6291                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6292                                    themeDisplay.getCompanyId());
6293    
6294                            themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6295    
6296                            List<Portlet> controlPanelPortlets = getControlPanelPortlets(
6297                                    PortletCategoryKeys.SITE_ADMINISTRATION, themeDisplay);
6298    
6299                            if (!controlPanelPortlets.isEmpty()) {
6300                                    return true;
6301                            }
6302                            else {
6303                                    return false;
6304                            }
6305                    }
6306                    finally {
6307                            themeDisplay.setScopeGroupId(scopeGroupId);
6308                    }
6309            }
6310    
6311            @Override
6312            public boolean isControlPanelPortlet(
6313                            String portletId, String category, ThemeDisplay themeDisplay)
6314                    throws SystemException {
6315    
6316                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
6317                            themeDisplay.getCompanyId(), portletId);
6318    
6319                    String controlPanelEntryCategory =
6320                            portlet.getControlPanelEntryCategory();
6321    
6322                    if (controlPanelEntryCategory.equals(category) ||
6323                            (category.endsWith(StringPool.PERIOD) &&
6324                             StringUtil.startsWith(controlPanelEntryCategory, category))) {
6325    
6326                            return isControlPanelPortlet(portletId, themeDisplay);
6327                    }
6328    
6329                    return false;
6330            }
6331    
6332            @Override
6333            public boolean isControlPanelPortlet(
6334                            String portletId, ThemeDisplay themeDisplay)
6335                    throws SystemException {
6336    
6337                    try {
6338                            return PortletPermissionUtil.hasControlPanelAccessPermission(
6339                                    themeDisplay.getPermissionChecker(),
6340                                    themeDisplay.getScopeGroupId(), portletId);
6341                    }
6342                    catch (PortalException pe) {
6343                            if (_log.isWarnEnabled()) {
6344                                    _log.warn(
6345                                            "Unable to check control panel access permission", pe);
6346                            }
6347                    }
6348    
6349                    return false;
6350            }
6351    
6352            @Override
6353            public boolean isGroupAdmin(User user, long groupId) throws Exception {
6354                    PermissionChecker permissionChecker =
6355                            PermissionCheckerFactoryUtil.create(user);
6356    
6357                    return permissionChecker.isGroupAdmin(groupId);
6358            }
6359    
6360            @Override
6361            public boolean isGroupFriendlyURL(
6362                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6363    
6364                    if (fullURL.endsWith(groupFriendlyURL) &&
6365                            !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6366    
6367                            return true;
6368                    }
6369    
6370                    return false;
6371            }
6372    
6373            @Override
6374            public boolean isGroupOwner(User user, long groupId) throws Exception {
6375                    PermissionChecker permissionChecker =
6376                            PermissionCheckerFactoryUtil.create(user);
6377    
6378                    return permissionChecker.isGroupOwner(groupId);
6379            }
6380    
6381            @Override
6382            public boolean isLayoutDescendant(Layout layout, long layoutId)
6383                    throws PortalException, SystemException {
6384    
6385                    if (layout.getLayoutId() == layoutId) {
6386                            return true;
6387                    }
6388    
6389                    for (Layout childLayout : layout.getChildren()) {
6390                            if (isLayoutDescendant(childLayout, layoutId)) {
6391                                    return true;
6392                            }
6393                    }
6394    
6395                    return false;
6396            }
6397    
6398            @Override
6399            public boolean isLayoutFirstPageable(Layout layout) {
6400                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6401    
6402                    return layoutSettings.isFirstPageable();
6403            }
6404    
6405            @Override
6406            public boolean isLayoutFirstPageable(String type) {
6407                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6408    
6409                    return layoutSettings.isFirstPageable();
6410            }
6411    
6412            @Override
6413            public boolean isLayoutFriendliable(Layout layout) {
6414                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6415    
6416                    return layoutSettings.isURLFriendliable();
6417            }
6418    
6419            @Override
6420            public boolean isLayoutFriendliable(String type) {
6421                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6422    
6423                    return layoutSettings.isURLFriendliable();
6424            }
6425    
6426            @Override
6427            public boolean isLayoutParentable(Layout layout) {
6428                    return isLayoutParentable(layout.getType());
6429            }
6430    
6431            @Override
6432            public boolean isLayoutParentable(String type) {
6433                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6434    
6435                    return layoutSettings.isParentable();
6436            }
6437    
6438            @Override
6439            public boolean isLayoutSitemapable(Layout layout) {
6440                    if (layout.isPrivateLayout()) {
6441                            return false;
6442                    }
6443    
6444                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6445    
6446                    return layoutSettings.isSitemapable();
6447            }
6448    
6449            @Override
6450            public boolean isLoginRedirectRequired(HttpServletRequest request)
6451                    throws SystemException {
6452    
6453                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6454                            !request.isSecure()) {
6455    
6456                            return true;
6457                    }
6458    
6459                    long companyId = PortalUtil.getCompanyId(request);
6460    
6461                    if (PrefsPropsUtil.getBoolean(
6462                                    companyId, PropsKeys.CAS_AUTH_ENABLED,
6463                                    PropsValues.CAS_AUTH_ENABLED) ||
6464                            PrefsPropsUtil.getBoolean(
6465                                    companyId, PropsKeys.LOGIN_DIALOG_DISABLED,
6466                                    PropsValues.LOGIN_DIALOG_DISABLED) ||
6467                            PrefsPropsUtil.getBoolean(
6468                                    companyId, PropsKeys.NTLM_AUTH_ENABLED,
6469                                    PropsValues.NTLM_AUTH_ENABLED) ||
6470                            PrefsPropsUtil.getBoolean(
6471                                    companyId, PropsKeys.OPEN_SSO_AUTH_ENABLED,
6472                                    PropsValues.OPEN_SSO_AUTH_ENABLED)) {
6473    
6474                            return true;
6475                    }
6476    
6477                    return false;
6478            }
6479    
6480            @Override
6481            public boolean isMethodGet(PortletRequest portletRequest) {
6482                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6483    
6484                    String method = GetterUtil.getString(request.getMethod());
6485    
6486                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6487                            return true;
6488                    }
6489                    else {
6490                            return false;
6491                    }
6492            }
6493    
6494            @Override
6495            public boolean isMethodPost(PortletRequest portletRequest) {
6496                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6497    
6498                    String method = GetterUtil.getString(request.getMethod());
6499    
6500                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6501                            return true;
6502                    }
6503                    else {
6504                            return false;
6505                    }
6506            }
6507    
6508            @Override
6509            public boolean isMultipartRequest(HttpServletRequest request) {
6510                    String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6511    
6512                    if ((contentType != null) &&
6513                            contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6514    
6515                            return true;
6516                    }
6517                    else {
6518                            return false;
6519                    }
6520            }
6521    
6522            @Override
6523            public boolean isOmniadmin(long userId) {
6524                    return OmniadminUtil.isOmniadmin(userId);
6525            }
6526    
6527            @Override
6528            public boolean isOmniadmin(User user) {
6529                    return OmniadminUtil.isOmniadmin(user);
6530            }
6531    
6532            @Override
6533            public boolean isReservedParameter(String name) {
6534                    return _reservedParams.contains(name);
6535            }
6536    
6537            @Override
6538            public boolean isRightToLeft(HttpServletRequest request) {
6539                    String languageId = LanguageUtil.getLanguageId(request);
6540    
6541                    Locale locale = LocaleUtil.fromLanguageId(languageId);
6542    
6543                    String langDir = LanguageUtil.get(locale, "lang.dir");
6544    
6545                    return langDir.equals("rtl");
6546            }
6547    
6548            @Override
6549            public boolean isRSSFeedsEnabled() {
6550                    return PropsValues.RSS_FEEDS_ENABLED;
6551            }
6552    
6553            @Override
6554            public boolean isSecure(HttpServletRequest request) {
6555                    HttpSession session = request.getSession();
6556    
6557                    if (session == null) {
6558                            return request.isSecure();
6559                    }
6560    
6561                    Boolean httpsInitial = (Boolean)session.getAttribute(
6562                            WebKeys.HTTPS_INITIAL);
6563    
6564                    boolean secure = false;
6565    
6566                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6567                            !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6568                            (httpsInitial != null) && !httpsInitial.booleanValue()) {
6569    
6570                            secure = false;
6571                    }
6572                    else {
6573                            secure = request.isSecure();
6574                    }
6575    
6576                    return secure;
6577            }
6578    
6579            @Override
6580            public boolean isSkipPortletContentProcessing(
6581                            Group group, HttpServletRequest httpServletRequest,
6582                            LayoutTypePortlet layoutTypePortlet, PortletDisplay portletDisplay,
6583                            String portletName)
6584                    throws Exception {
6585    
6586                    boolean skipPortletContentRendering = isSkipPortletContentRendering(
6587                            group, layoutTypePortlet, portletDisplay, portletName);
6588    
6589                    if (!skipPortletContentRendering) {
6590                            return false;
6591                    }
6592    
6593                    ServletContext servletContext =
6594                            (ServletContext)httpServletRequest.getAttribute(WebKeys.CTX);
6595    
6596                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
6597                            group.getCompanyId(), portletDisplay.getId());
6598    
6599                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
6600                            portlet, servletContext);
6601    
6602                    if (invokerPortlet.isStrutsBridgePortlet() ||
6603                            invokerPortlet.isStrutsPortlet()) {
6604    
6605                            return false;
6606                    }
6607    
6608                    return true;
6609            }
6610    
6611            @Override
6612            public boolean isSkipPortletContentRendering(
6613                            Group group, LayoutTypePortlet layoutTypePortlet,
6614                            PortletDisplay portletDisplay, String portletName)
6615                    throws PortalException, SystemException {
6616    
6617                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
6618                            group.getCompanyId(), portletDisplay.getId());
6619    
6620                    if (portlet.isSystem()) {
6621                            return false;
6622                    }
6623    
6624                    if (group.isLayoutPrototype() &&
6625                            layoutTypePortlet.hasPortletId(portletDisplay.getId()) &&
6626                            portletDisplay.isModeView() &&
6627                            !portletName.equals(PortletKeys.NESTED_PORTLETS)) {
6628    
6629                            return true;
6630                    }
6631    
6632                    return false;
6633            }
6634    
6635            @Override
6636            public boolean isSystemGroup(String groupName) {
6637                    if (groupName == null) {
6638                            return false;
6639                    }
6640    
6641                    groupName = groupName.trim();
6642    
6643                    int pos = Arrays.binarySearch(
6644                            _sortedSystemGroups, groupName, new StringComparator());
6645    
6646                    if (pos >= 0) {
6647                            return true;
6648                    }
6649                    else {
6650                            return false;
6651                    }
6652            }
6653    
6654            @Override
6655            public boolean isSystemRole(String roleName) {
6656                    if (roleName == null) {
6657                            return false;
6658                    }
6659    
6660                    roleName = roleName.trim();
6661    
6662                    int pos = Arrays.binarySearch(
6663                            _sortedSystemRoles, roleName, new StringComparator());
6664    
6665                    if (pos >= 0) {
6666                            return true;
6667                    }
6668    
6669                    pos = Arrays.binarySearch(
6670                            _sortedSystemSiteRoles, roleName, new StringComparator());
6671    
6672                    if (pos >= 0) {
6673                            return true;
6674                    }
6675    
6676                    pos = Arrays.binarySearch(
6677                            _sortedSystemOrganizationRoles, roleName, new StringComparator());
6678    
6679                    if (pos >= 0) {
6680                            return true;
6681                    }
6682    
6683                    return false;
6684            }
6685    
6686            @Override
6687            public boolean isUpdateAvailable() throws SystemException {
6688                    return PluginPackageUtil.isUpdateAvailable();
6689            }
6690    
6691            @Override
6692            public boolean isValidResourceId(String resourceId) {
6693                    if (Validator.isNull(resourceId)) {
6694                            return true;
6695                    }
6696    
6697                    Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6698    
6699                    if (matcher.matches()) {
6700                            return false;
6701                    }
6702    
6703                    return true;
6704            }
6705    
6706            @Override
6707            public void removePortalPortEventListener(
6708                    PortalPortEventListener portalPortEventListener) {
6709    
6710                    _portalPortEventListeners.remove(portalPortEventListener);
6711            }
6712    
6713            @Override
6714            public void resetCDNHosts() {
6715                    _cdnHostHttpMap.clear();
6716                    _cdnHostHttpsMap.clear();
6717    
6718                    if (!ClusterInvokeThreadLocal.isEnabled()) {
6719                            return;
6720                    }
6721    
6722                    ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6723                            _resetCDNHostsMethodHandler, true);
6724    
6725                    try {
6726                            ClusterExecutorUtil.execute(clusterRequest);
6727                    }
6728                    catch (Exception e) {
6729                            _log.error("Unable to clear cluster wide CDN hosts", e);
6730                    }
6731            }
6732    
6733            /**
6734             * @deprecated As of 6.2.0, replaced by {@link
6735             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelist}
6736             */
6737            @Override
6738            public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6739                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6740            }
6741    
6742            /**
6743             * @deprecated As of 6.2.0, replaced by {@link
6744             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelistActions}
6745             */
6746            @Override
6747            public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6748                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6749            }
6750    
6751            @Override
6752            public String resetPortletParameters(String url, String portletId) {
6753                    if (Validator.isNull(url) || Validator.isNull(portletId)) {
6754                            return url;
6755                    }
6756    
6757                    String portletNamespace = getPortletNamespace(portletId);
6758    
6759                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(url);
6760    
6761                    for (String name : parameterMap.keySet()) {
6762                            if (name.startsWith(portletNamespace)) {
6763                                    url = HttpUtil.removeParameter(url, name);
6764                            }
6765                    }
6766    
6767                    return url;
6768            }
6769    
6770            @Override
6771            public void sendError(
6772                            Exception e, ActionRequest actionRequest,
6773                            ActionResponse actionResponse)
6774                    throws IOException {
6775    
6776                    sendError(0, e, actionRequest, actionResponse);
6777            }
6778    
6779            @Override
6780            public void sendError(
6781                            Exception e, HttpServletRequest request,
6782                            HttpServletResponse response)
6783                    throws IOException, ServletException {
6784    
6785                    sendError(0, e, request, response);
6786            }
6787    
6788            @Override
6789            public void sendError(
6790                            int status, Exception e, ActionRequest actionRequest,
6791                            ActionResponse actionResponse)
6792                    throws IOException {
6793    
6794                    StringBundler sb = new StringBundler(7);
6795    
6796                    sb.append(_pathMain);
6797                    sb.append("/portal/status?status=");
6798                    sb.append(status);
6799                    sb.append("&exception=");
6800                    sb.append(e.getClass().getName());
6801                    sb.append("&previousURL=");
6802                    sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6803    
6804                    actionResponse.sendRedirect(sb.toString());
6805            }
6806    
6807            @Override
6808            public void sendError(
6809                            int status, Exception e, HttpServletRequest request,
6810                            HttpServletResponse response)
6811                    throws IOException, ServletException {
6812    
6813                    if (_log.isDebugEnabled()) {
6814                            String currentURL = (String)request.getAttribute(
6815                                    WebKeys.CURRENT_URL);
6816    
6817                            _log.debug(
6818                                    "Current URL " + currentURL + " generates exception: " +
6819                                            e.getMessage());
6820                    }
6821    
6822                    if (e instanceof NoSuchImageException) {
6823                            if (_logWebServerServlet.isWarnEnabled()) {
6824                                    _logWebServerServlet.warn(e, e);
6825                            }
6826                    }
6827                    else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6828                            if ((e instanceof NoSuchLayoutException) ||
6829                                    (e instanceof PrincipalException)) {
6830    
6831                                    String msg = e.getMessage();
6832    
6833                                    if (Validator.isNotNull(msg)) {
6834                                            _log.debug(msg);
6835                                    }
6836                            }
6837                            else {
6838                                    _log.debug(e, e);
6839                            }
6840                    }
6841                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6842                            _log.warn(e, e);
6843                    }
6844    
6845                    if (response.isCommitted()) {
6846                            return;
6847                    }
6848    
6849                    if (status == 0) {
6850                            if (e instanceof PrincipalException) {
6851                                    status = HttpServletResponse.SC_FORBIDDEN;
6852                            }
6853                            else {
6854                                    String name = e.getClass().getName();
6855    
6856                                    name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6857    
6858                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6859                                            status = HttpServletResponse.SC_NOT_FOUND;
6860                                    }
6861                            }
6862    
6863                            if (status == 0) {
6864    
6865                                    // LPS-5352
6866    
6867                                    if (PropsValues.TCK_URL) {
6868                                            status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
6869                                    }
6870                                    else {
6871                                            status = HttpServletResponse.SC_BAD_REQUEST;
6872                                    }
6873                            }
6874                    }
6875    
6876                    String redirect = null;
6877    
6878                    if ((e instanceof NoSuchGroupException) &&
6879                            Validator.isNotNull(
6880                                    PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6881    
6882                            redirect = PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND;
6883                    }
6884                    else if ((e instanceof NoSuchLayoutException) &&
6885                                     Validator.isNotNull(
6886                                            PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6887    
6888                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6889                    }
6890                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6891                            redirect = PATH_MAIN + "/portal/status";
6892                    }
6893    
6894                    if (Validator.equals(redirect, request.getRequestURI())) {
6895                            if (_log.isWarnEnabled()) {
6896                                    _log.warn("Unable to redirect to missing URI: " + redirect);
6897                            }
6898    
6899                            redirect = null;
6900                    }
6901    
6902                    if (Validator.isNotNull(redirect)) {
6903                            HttpSession session = PortalSessionThreadLocal.getHttpSession();
6904    
6905                            if (session == null) {
6906                                    session = request.getSession();
6907                            }
6908    
6909                            response.setStatus(status);
6910    
6911                            SessionErrors.add(session, e.getClass(), e);
6912    
6913                            ServletContext servletContext = session.getServletContext();
6914    
6915                            RequestDispatcher requestDispatcher =
6916                                    servletContext.getRequestDispatcher(redirect);
6917    
6918                            if (requestDispatcher != null) {
6919                                    requestDispatcher.forward(request, response);
6920                            }
6921                    }
6922                    else if (e != null) {
6923                            response.sendError(status, e.getMessage());
6924                    }
6925                    else {
6926                            String currentURL = (String)request.getAttribute(
6927                                    WebKeys.CURRENT_URL);
6928    
6929                            response.sendError(status, "Current URL " + currentURL);
6930                    }
6931            }
6932    
6933            @Override
6934            public void sendRSSFeedsDisabledError(
6935                            HttpServletRequest request, HttpServletResponse response)
6936                    throws IOException, ServletException {
6937    
6938                    sendError(
6939                            HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
6940                            request, response);
6941            }
6942    
6943            @Override
6944            public void sendRSSFeedsDisabledError(
6945                            PortletRequest portletRequest, PortletResponse portletResponse)
6946                    throws IOException, ServletException {
6947    
6948                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6949                    HttpServletResponse response = getHttpServletResponse(portletResponse);
6950    
6951                    sendRSSFeedsDisabledError(request, response);
6952            }
6953    
6954            @Override
6955            public void setPageDescription(
6956                    String description, HttpServletRequest request) {
6957    
6958                    ListMergeable<String> descriptionListMergeable =
6959                            new ListMergeable<String>();
6960    
6961                    descriptionListMergeable.add(description);
6962    
6963                    request.setAttribute(
6964                            WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6965            }
6966    
6967            @Override
6968            public void setPageKeywords(String keywords, HttpServletRequest request) {
6969                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6970    
6971                    addPageKeywords(keywords, request);
6972            }
6973    
6974            @Override
6975            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6976                    ListMergeable<String> subtitleListMergeable =
6977                            new ListMergeable<String>();
6978    
6979                    subtitleListMergeable.add(subtitle);
6980    
6981                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6982            }
6983    
6984            @Override
6985            public void setPageTitle(String title, HttpServletRequest request) {
6986                    ListMergeable<String> titleListMergeable = new ListMergeable<String>();
6987    
6988                    titleListMergeable.add(title);
6989    
6990                    request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6991            }
6992    
6993            @Override
6994            public void setPortalPort(HttpServletRequest request) {
6995                    boolean secure = request.isSecure();
6996    
6997                    if (secure) {
6998                            if (_securePortalPort.get() == -1) {
6999                                    int securePortalPort = request.getServerPort();
7000    
7001                                    if (_securePortalPort.compareAndSet(-1, securePortalPort)) {
7002                                            notifyPortalPortEventListeners(securePortalPort);
7003                                            notifyPortalPortProtocolEventListeners(
7004                                                    securePortalPort, true);
7005                                    }
7006                            }
7007                    }
7008                    else {
7009                            if (_portalPort.get() == -1) {
7010                                    int portalPort = request.getServerPort();
7011    
7012                                    if (_portalPort.compareAndSet(-1, portalPort)) {
7013                                            notifyPortalPortEventListeners(portalPort);
7014                                            notifyPortalPortProtocolEventListeners(portalPort, false);
7015                                    }
7016                            }
7017                    }
7018            }
7019    
7020            @Override
7021            public void storePreferences(PortletPreferences portletPreferences)
7022                    throws IOException, ValidatorException {
7023    
7024                    PortletPreferencesWrapper portletPreferencesWrapper =
7025                            (PortletPreferencesWrapper)portletPreferences;
7026    
7027                    PortletPreferencesImpl portletPreferencesImpl =
7028                            portletPreferencesWrapper.getPortletPreferencesImpl();
7029    
7030                    portletPreferencesImpl.store();
7031            }
7032    
7033            @Override
7034            public String[] stripURLAnchor(String url, String separator) {
7035                    String anchor = StringPool.BLANK;
7036    
7037                    int pos = url.indexOf(separator);
7038    
7039                    if (pos != -1) {
7040                            anchor = url.substring(pos);
7041                            url = url.substring(0, pos);
7042                    }
7043    
7044                    return new String[] {url, anchor};
7045            }
7046    
7047            @Override
7048            public String transformCustomSQL(String sql) {
7049                    if ((_customSqlKeys == null) || (_customSqlValues == null)) {
7050                            initCustomSQL();
7051                    }
7052    
7053                    return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
7054            }
7055    
7056            @Override
7057            public String transformSQL(String sql) {
7058                    return SQLTransformer.transform(sql);
7059            }
7060    
7061            @Override
7062            public PortletMode updatePortletMode(
7063                            String portletId, User user, Layout layout, PortletMode portletMode,
7064                            HttpServletRequest request)
7065                    throws PortalException, SystemException {
7066    
7067                    LayoutTypePortlet layoutType =
7068                            (LayoutTypePortlet)layout.getLayoutType();
7069    
7070                    if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
7071                            if (layoutType.hasModeAboutPortletId(portletId)) {
7072                                    return LiferayPortletMode.ABOUT;
7073                            }
7074                            else if (layoutType.hasModeConfigPortletId(portletId)) {
7075                                    return LiferayPortletMode.CONFIG;
7076                            }
7077                            else if (layoutType.hasModeEditPortletId(portletId)) {
7078                                    return PortletMode.EDIT;
7079                            }
7080                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
7081                                    return LiferayPortletMode.EDIT_DEFAULTS;
7082                            }
7083                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
7084                                    return LiferayPortletMode.EDIT_GUEST;
7085                            }
7086                            else if (layoutType.hasModeHelpPortletId(portletId)) {
7087                                    return PortletMode.HELP;
7088                            }
7089                            else if (layoutType.hasModePreviewPortletId(portletId)) {
7090                                    return LiferayPortletMode.PREVIEW;
7091                            }
7092                            else if (layoutType.hasModePrintPortletId(portletId)) {
7093                                    return LiferayPortletMode.PRINT;
7094                            }
7095                            else {
7096                                    return PortletMode.VIEW;
7097                            }
7098                    }
7099                    else {
7100                            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7101                                    WebKeys.THEME_DISPLAY);
7102    
7103                            PermissionChecker permissionChecker =
7104                                    themeDisplay.getPermissionChecker();
7105    
7106                            Portlet portlet = PortletLocalServiceUtil.getPortletById(
7107                                    getCompanyId(request), portletId);
7108    
7109                            if (!PortletPermissionUtil.contains(
7110                                            permissionChecker, getScopeGroupId(request), layout,
7111                                            portlet, ActionKeys.VIEW)) {
7112    
7113                                    return portletMode;
7114                            }
7115    
7116                            boolean updateLayout = false;
7117    
7118                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
7119                                    !layoutType.hasModeAboutPortletId(portletId)) {
7120    
7121                                    layoutType.addModeAboutPortletId(portletId);
7122    
7123                                    updateLayout = true;
7124                            }
7125                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
7126                                             !layoutType.hasModeConfigPortletId(portletId) &&
7127                                             PortletPermissionUtil.contains(
7128                                                     permissionChecker, getScopeGroupId(request), layout,
7129                                                     portlet, ActionKeys.CONFIGURATION)) {
7130    
7131                                    layoutType.addModeConfigPortletId(portletId);
7132    
7133                                    updateLayout = true;
7134                            }
7135                            else if (portletMode.equals(PortletMode.EDIT) &&
7136                                             !layoutType.hasModeEditPortletId(portletId) &&
7137                                             PortletPermissionUtil.contains(
7138                                                     permissionChecker, getScopeGroupId(request), layout,
7139                                                     portlet, ActionKeys.PREFERENCES)) {
7140    
7141                                    layoutType.addModeEditPortletId(portletId);
7142    
7143                                    updateLayout = true;
7144                            }
7145                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
7146                                             !layoutType.hasModeEditDefaultsPortletId(portletId) &&
7147                                             PortletPermissionUtil.contains(
7148                                                     permissionChecker, getScopeGroupId(request), layout,
7149                                                     portlet, ActionKeys.PREFERENCES)) {
7150    
7151                                    layoutType.addModeEditDefaultsPortletId(portletId);
7152    
7153                                    updateLayout = true;
7154                            }
7155                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
7156                                             !layoutType.hasModeEditGuestPortletId(portletId) &&
7157                                             PortletPermissionUtil.contains(
7158                                                     permissionChecker, getScopeGroupId(request), layout,
7159                                                     portlet, ActionKeys.GUEST_PREFERENCES)) {
7160    
7161                                    layoutType.addModeEditGuestPortletId(portletId);
7162    
7163                                    updateLayout = true;
7164                            }
7165                            else if (portletMode.equals(PortletMode.HELP) &&
7166                                             !layoutType.hasModeHelpPortletId(portletId)) {
7167    
7168                                    layoutType.addModeHelpPortletId(portletId);
7169    
7170                                    updateLayout = true;
7171                            }
7172                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
7173                                             !layoutType.hasModePreviewPortletId(portletId)) {
7174    
7175                                    layoutType.addModePreviewPortletId(portletId);
7176    
7177                                    updateLayout = true;
7178                            }
7179                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
7180                                             !layoutType.hasModePrintPortletId(portletId)) {
7181    
7182                                    layoutType.addModePrintPortletId(portletId);
7183    
7184                                    updateLayout = true;
7185                            }
7186                            else if (portletMode.equals(PortletMode.VIEW) &&
7187                                             !layoutType.hasModeViewPortletId(portletId)) {
7188    
7189                                    layoutType.removeModesPortletId(portletId);
7190    
7191                                    updateLayout = true;
7192                            }
7193    
7194                            if (updateLayout) {
7195                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7196    
7197                                    if (layoutClone != null) {
7198                                            layoutClone.update(
7199                                                    request, layout.getPlid(), layout.getTypeSettings());
7200                                    }
7201                            }
7202    
7203                            return portletMode;
7204                    }
7205            }
7206    
7207            @Override
7208            public String updateRedirect(
7209                    String redirect, String oldPath, String newPath) {
7210    
7211                    if (Validator.isNull(redirect) || (oldPath == null) ||
7212                            oldPath.equals(newPath)) {
7213    
7214                            return redirect;
7215                    }
7216    
7217                    String queryString = HttpUtil.getQueryString(redirect);
7218    
7219                    String redirectParam = HttpUtil.getParameter(
7220                            redirect, "redirect", false);
7221    
7222                    if (Validator.isNotNull(redirectParam)) {
7223                            String newRedirectParam = StringUtil.replace(
7224                                    redirectParam, HttpUtil.encodeURL(oldPath),
7225                                    HttpUtil.encodeURL(newPath));
7226    
7227                            queryString = StringUtil.replace(
7228                                    queryString, redirectParam, newRedirectParam);
7229                    }
7230    
7231                    String redirectPath = HttpUtil.getPath(redirect);
7232    
7233                    int pos = redirect.indexOf(redirectPath);
7234    
7235                    String prefix = redirect.substring(0, pos);
7236    
7237                    pos = redirectPath.lastIndexOf(oldPath);
7238    
7239                    if (pos != -1) {
7240                            prefix += redirectPath.substring(0, pos);
7241    
7242                            String suffix = redirectPath.substring(pos + oldPath.length());
7243    
7244                            redirect = prefix + newPath + suffix;
7245                    }
7246                    else {
7247                            redirect = prefix + redirectPath;
7248                    }
7249    
7250                    if (Validator.isNotNull(queryString)) {
7251                            redirect += StringPool.QUESTION + queryString;
7252                    }
7253    
7254                    return redirect;
7255            }
7256    
7257            @Override
7258            public WindowState updateWindowState(
7259                    String portletId, User user, Layout layout, WindowState windowState,
7260                    HttpServletRequest request) {
7261    
7262                    LayoutTypePortlet layoutType =
7263                            (LayoutTypePortlet)layout.getLayoutType();
7264    
7265                    if ((windowState == null) || Validator.isNull(windowState.toString())) {
7266                            if (layoutType.hasStateMaxPortletId(portletId)) {
7267                                    windowState = WindowState.MAXIMIZED;
7268                            }
7269                            else if (layoutType.hasStateMinPortletId(portletId)) {
7270                                    windowState = WindowState.MINIMIZED;
7271                            }
7272                            else {
7273                                    windowState = WindowState.NORMAL;
7274                            }
7275                    }
7276                    else {
7277                            boolean updateLayout = false;
7278    
7279                            if (windowState.equals(WindowState.MAXIMIZED) &&
7280                                    !layoutType.hasStateMaxPortletId(portletId)) {
7281    
7282                                    layoutType.addStateMaxPortletId(portletId);
7283    
7284                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
7285                                            updateLayout = true;
7286                                    }
7287                            }
7288                            else if (windowState.equals(WindowState.MINIMIZED) &&
7289                                             !layoutType.hasStateMinPortletId(portletId)) {
7290    
7291                                    layoutType.addStateMinPortletId(portletId);
7292    
7293                                    updateLayout = true;
7294                            }
7295                            else if (windowState.equals(WindowState.NORMAL) &&
7296                                             !layoutType.hasStateNormalPortletId(portletId)) {
7297    
7298                                    layoutType.removeStatesPortletId(portletId);
7299    
7300                                    updateLayout = true;
7301                            }
7302    
7303                            if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
7304                                    portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
7305    
7306                                    updateLayout = false;
7307                            }
7308    
7309                            if (updateLayout) {
7310                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7311    
7312                                    if (layoutClone != null) {
7313                                            layoutClone.update(
7314                                                    request, layout.getPlid(), layout.getTypeSettings());
7315                                    }
7316                            }
7317                    }
7318    
7319                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7320                            WebKeys.THEME_DISPLAY);
7321    
7322                    themeDisplay.setStateExclusive(
7323                            windowState.equals(LiferayWindowState.EXCLUSIVE));
7324                    themeDisplay.setStateMaximized(
7325                            windowState.equals(WindowState.MAXIMIZED));
7326                    themeDisplay.setStatePopUp(
7327                            windowState.equals(LiferayWindowState.POP_UP));
7328    
7329                    if (themeDisplay.isStateMaximized() &&
7330                            themeDisplay.isShowAddContentIcon()) {
7331    
7332                            themeDisplay.setShowAddContentIcon(false);
7333                    }
7334                    else if (!themeDisplay.isStateMaximized() &&
7335                                     !themeDisplay.isShowAddContentIcon() &&
7336                                     themeDisplay.isShowAddContentIconPermission()) {
7337    
7338                            themeDisplay.setShowAddContentIcon(true);
7339                    }
7340    
7341                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
7342    
7343                    return windowState;
7344            }
7345    
7346            protected void addDefaultResource(
7347                            long companyId, Layout layout, Portlet portlet,
7348                            boolean portletActions)
7349                    throws PortalException, SystemException {
7350    
7351                    long groupId = getScopeGroupId(layout, portlet.getPortletId());
7352    
7353                    addDefaultResource(companyId, groupId, layout, portlet, portletActions);
7354            }
7355    
7356            protected void addDefaultResource(
7357                            long companyId, long groupId, Layout layout, Portlet portlet,
7358                            boolean portletActions)
7359                    throws PortalException, SystemException {
7360    
7361                    String rootPortletId = portlet.getRootPortletId();
7362    
7363                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
7364                            layout.getPlid(), portlet.getPortletId());
7365    
7366                    String name = null;
7367                    String primaryKey = null;
7368    
7369                    if (portletActions) {
7370                            name = rootPortletId;
7371                            primaryKey = portletPrimaryKey;
7372                    }
7373                    else {
7374                            Group group = GroupLocalServiceUtil.fetchGroup(groupId);
7375    
7376                            if ((group != null) && group.isStagingGroup()) {
7377                                    groupId = group.getLiveGroupId();
7378                            }
7379    
7380                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
7381                            primaryKey = String.valueOf(groupId);
7382                    }
7383    
7384                    if (Validator.isNull(name)) {
7385                            return;
7386                    }
7387    
7388                    int count =
7389                            ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
7390                                    companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
7391                                    primaryKey);
7392    
7393                    if (count > 0) {
7394                            return;
7395                    }
7396    
7397                    boolean addGuestPermissions = true;
7398    
7399                    if (portletActions) {
7400                            Group layoutGroup = layout.getGroup();
7401    
7402                            if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype() &&
7403                                    !layoutGroup.isLayoutSetPrototype()) {
7404    
7405                                    addGuestPermissions = false;
7406                            }
7407                    }
7408    
7409                    ResourceLocalServiceUtil.addResources(
7410                            companyId, groupId, 0, name, primaryKey, portletActions, true,
7411                            addGuestPermissions);
7412            }
7413    
7414            protected String buildI18NPath(Locale locale) {
7415                    String languageId = LocaleUtil.toLanguageId(locale);
7416    
7417                    if (Validator.isNull(languageId)) {
7418                            return null;
7419                    }
7420    
7421                    if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
7422                            Locale priorityLocale = LanguageUtil.getLocale(
7423                                    locale.getLanguage());
7424    
7425                            if (locale.equals(priorityLocale)) {
7426                                    languageId = locale.getLanguage();
7427                            }
7428                    }
7429                    else {
7430                            languageId = locale.getLanguage();
7431                    }
7432    
7433                    return StringPool.SLASH.concat(languageId);
7434            }
7435    
7436            protected List<Group> doGetAncestorSiteGroups(
7437                            long groupId, boolean checkContentSharingWithChildrenEnabled)
7438                    throws PortalException, SystemException {
7439    
7440                    List<Group> groups = new UniqueList<Group>();
7441    
7442                    long siteGroupId = getSiteGroupId(groupId);
7443    
7444                    Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7445    
7446                    for (Group group : siteGroup.getAncestors()) {
7447                            if (checkContentSharingWithChildrenEnabled &&
7448                                    !SitesUtil.isContentSharingWithChildrenEnabled(group)) {
7449    
7450                                    continue;
7451                            }
7452    
7453                            groups.add(group);
7454                    }
7455    
7456                    if (!siteGroup.isCompany()) {
7457                            groups.add(
7458                                    GroupLocalServiceUtil.getCompanyGroup(
7459                                            siteGroup.getCompanyId()));
7460                    }
7461    
7462                    return groups;
7463            }
7464    
7465            protected Group doGetCurrentSiteGroup(long groupId)
7466                    throws PortalException, SystemException {
7467    
7468                    long siteGroupId = getSiteGroupId(groupId);
7469    
7470                    Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7471    
7472                    if (!siteGroup.isLayoutPrototype()) {
7473                            return siteGroup;
7474                    }
7475    
7476                    return null;
7477            }
7478    
7479            protected long doGetPlidFromPortletId(
7480                            long groupId, boolean privateLayout, String portletId)
7481                    throws PortalException, SystemException {
7482    
7483                    long scopeGroupId = groupId;
7484    
7485                    try {
7486                            Group group = GroupLocalServiceUtil.getGroup(groupId);
7487    
7488                            if (group.isLayout()) {
7489                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7490                                            group.getClassPK());
7491    
7492                                    groupId = scopeLayout.getGroupId();
7493                            }
7494                    }
7495                    catch (Exception e) {
7496                    }
7497    
7498                    long plid = LayoutConstants.DEFAULT_PLID;
7499    
7500                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7501                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7502    
7503                    for (Layout layout : layouts) {
7504                            LayoutTypePortlet layoutTypePortlet =
7505                                    (LayoutTypePortlet)layout.getLayoutType();
7506    
7507                            if (layoutTypePortlet.hasPortletId(portletId, true)) {
7508                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7509                                            plid = layout.getPlid();
7510    
7511                                            break;
7512                                    }
7513                            }
7514                    }
7515    
7516                    return plid;
7517            }
7518    
7519            protected List<Portlet> filterControlPanelPortlets(
7520                    Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7521    
7522                    List<Portlet> filteredPortlets = new ArrayList<Portlet>(portlets);
7523    
7524                    Iterator<Portlet> itr = filteredPortlets.iterator();
7525    
7526                    while (itr.hasNext()) {
7527                            Portlet portlet = itr.next();
7528    
7529                            try {
7530                                    if (!portlet.isActive() || portlet.isInstanceable() ||
7531                                            !PortletPermissionUtil.hasControlPanelAccessPermission(
7532                                                    themeDisplay.getPermissionChecker(),
7533                                                    themeDisplay.getScopeGroupId(), portlet)) {
7534    
7535                                            itr.remove();
7536                                    }
7537                            }
7538                            catch (Exception e) {
7539                                    _log.error(e, e);
7540    
7541                                    itr.remove();
7542                            }
7543                    }
7544    
7545                    return filteredPortlets;
7546            }
7547    
7548            protected Locale getAvailableLocale(long groupId, Locale locale) {
7549                    if (Validator.isNull(locale.getCountry())) {
7550    
7551                            // Locales must contain a country code
7552    
7553                            locale = LanguageUtil.getLocale(locale.getLanguage());
7554                    }
7555    
7556                    if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7557                            return null;
7558                    }
7559    
7560                    return locale;
7561            }
7562    
7563            protected String getCanonicalDomain(
7564                    String virtualHostname, String portalDomain) {
7565    
7566                    if (Validator.isBlank(portalDomain) ||
7567                            StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) ||
7568                            !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7569    
7570                            return virtualHostname;
7571                    }
7572    
7573                    int pos = portalDomain.indexOf(CharPool.COLON);
7574    
7575                    if (pos == -1) {
7576                            return portalDomain;
7577                    }
7578    
7579                    return portalDomain.substring(0, pos);
7580            }
7581    
7582            protected Map<String, List<Portlet>> getCategoriesMap(
7583                            HttpServletRequest request, String attributeName,
7584                            String[] categories)
7585                    throws SystemException {
7586    
7587                    Map<String, List<Portlet>> categoriesMap =
7588                            (Map<String, List<Portlet>>)request.getAttribute(attributeName);
7589    
7590                    if (categoriesMap != null) {
7591                            return categoriesMap;
7592                    }
7593    
7594                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7595                            WebKeys.THEME_DISPLAY);
7596    
7597                    categoriesMap = new LinkedHashMap<String, List<Portlet>>();
7598    
7599                    for (String category : categories) {
7600                            List<Portlet> portlets = getControlPanelPortlets(
7601                                    category, themeDisplay);
7602    
7603                            if (!portlets.isEmpty()) {
7604                                    categoriesMap.put(category, portlets);
7605                            }
7606                    }
7607    
7608                    request.setAttribute(attributeName, categoriesMap);
7609    
7610                    return categoriesMap;
7611            }
7612    
7613            protected long getDefaultScopeGroupId(long companyId)
7614                    throws PortalException, SystemException {
7615    
7616                    long doAsGroupId = 0;
7617    
7618                    Collection<Portlet> portlets = getControlPanelPortlets(
7619                            companyId, PortletCategoryKeys.SITE_ADMINISTRATION);
7620    
7621                    List<Group> groups = GroupServiceUtil.getManageableSiteGroups(
7622                            portlets, 1);
7623    
7624                    if (!groups.isEmpty()) {
7625                            Group group = groups.get(0);
7626    
7627                            doAsGroupId = group.getGroupId();
7628                    }
7629                    else {
7630                            Group guestGroup = GroupLocalServiceUtil.fetchGroup(
7631                                    companyId, GroupConstants.GUEST);
7632    
7633                            if (guestGroup != null) {
7634                                    doAsGroupId = guestGroup.getGroupId();
7635                            }
7636                    }
7637    
7638                    return doAsGroupId;
7639            }
7640    
7641            protected long getDoAsUserId(
7642                            HttpServletRequest request, String doAsUserIdString,
7643                            boolean alwaysAllowDoAsUser)
7644                    throws Exception {
7645    
7646                    if (Validator.isNull(doAsUserIdString)) {
7647                            return 0;
7648                    }
7649    
7650                    long doAsUserId = 0;
7651    
7652                    try {
7653                            Company company = getCompany(request);
7654    
7655                            doAsUserId = GetterUtil.getLong(
7656                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7657                    }
7658                    catch (Exception e) {
7659                            if (_log.isWarnEnabled()) {
7660                                    _log.warn(
7661                                            "Unable to impersonate " + doAsUserIdString +
7662                                                    " because the string cannot be decrypted");
7663                            }
7664    
7665                            return 0;
7666                    }
7667    
7668                    if (_log.isDebugEnabled()) {
7669                            if (alwaysAllowDoAsUser) {
7670                                    _log.debug(
7671                                            "doAsUserId path or Struts action is always allowed");
7672                            }
7673                            else {
7674                                    _log.debug(
7675                                            "doAsUserId path is Struts action not always allowed");
7676                            }
7677                    }
7678    
7679                    if (alwaysAllowDoAsUser) {
7680                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7681    
7682                            return doAsUserId;
7683                    }
7684    
7685                    HttpSession session = request.getSession();
7686    
7687                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7688    
7689                    if (realUserIdObj == null) {
7690                            return 0;
7691                    }
7692    
7693                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7694    
7695                    long[] organizationIds = doAsUser.getOrganizationIds();
7696    
7697                    User realUser = UserLocalServiceUtil.getUserById(
7698                            realUserIdObj.longValue());
7699    
7700                    PermissionChecker permissionChecker =
7701                            PermissionCheckerFactoryUtil.create(realUser);
7702    
7703                    if (doAsUser.isDefaultUser() ||
7704                            UserPermissionUtil.contains(
7705                                    permissionChecker, doAsUserId, organizationIds,
7706                                    ActionKeys.IMPERSONATE)) {
7707    
7708                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7709    
7710                            return doAsUserId;
7711                    }
7712    
7713                    _log.error(
7714                            "User " + realUserIdObj + " does not have the permission to " +
7715                                    "impersonate " + doAsUserId);
7716    
7717                    return 0;
7718            }
7719    
7720            protected String getGroupFriendlyURL(
7721                            LayoutSet layoutSet, ThemeDisplay themeDisplay,
7722                            boolean canonicalURL)
7723                    throws PortalException, SystemException {
7724    
7725                    Group group = layoutSet.getGroup();
7726    
7727                    boolean privateLayoutSet = layoutSet.getPrivateLayout();
7728    
7729                    String portalURL = themeDisplay.getPortalURL();
7730    
7731                    boolean useGroupVirtualHostName = false;
7732    
7733                    if (canonicalURL ||
7734                            !StringUtil.equalsIgnoreCase(
7735                                    themeDisplay.getServerName(), _LOCALHOST)) {
7736    
7737                            useGroupVirtualHostName = true;
7738                    }
7739    
7740                    long refererPlid = themeDisplay.getRefererPlid();
7741    
7742                    if (refererPlid > 0) {
7743                            Layout refererLayout = LayoutLocalServiceUtil.fetchLayout(
7744                                    refererPlid);
7745    
7746                            if ((refererLayout != null) &&
7747                                    ((refererLayout.getGroupId() != group.getGroupId()) ||
7748                                     (refererLayout.isPrivateLayout() != privateLayoutSet))) {
7749    
7750                                    useGroupVirtualHostName = false;
7751                            }
7752                    }
7753    
7754                    if (useGroupVirtualHostName) {
7755                            String virtualHostname = getVirtualHostname(layoutSet);
7756    
7757                            String portalDomain = themeDisplay.getPortalDomain();
7758    
7759                            if (Validator.isNotNull(virtualHostname) &&
7760                                    (canonicalURL ||
7761                                     !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7762    
7763                                    virtualHostname = getCanonicalDomain(
7764                                            virtualHostname, portalDomain);
7765    
7766                                    virtualHostname = getPortalURL(
7767                                            virtualHostname, themeDisplay.getServerPort(),
7768                                            themeDisplay.isSecure());
7769    
7770                                    if (canonicalURL || virtualHostname.contains(portalDomain)) {
7771                                            String path = StringPool.BLANK;
7772    
7773                                            if (themeDisplay.isWidget()) {
7774                                                    path = PropsValues.WIDGET_SERVLET_MAPPING;
7775                                            }
7776    
7777                                            if (themeDisplay.isI18n() && !canonicalURL) {
7778                                                    path = themeDisplay.getI18nPath();
7779                                            }
7780    
7781                                            return virtualHostname.concat(_pathContext).concat(path);
7782                                    }
7783                            }
7784                            else {
7785                                    LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7786                                            themeDisplay.getSiteGroupId(), privateLayoutSet);
7787    
7788                                    if (canonicalURL ||
7789                                            ((layoutSet.getLayoutSetId() !=
7790                                                    curLayoutSet.getLayoutSetId()) &&
7791                                             (group.getClassPK() != themeDisplay.getUserId()))) {
7792    
7793                                            if (group.isControlPanel()) {
7794                                                    virtualHostname = themeDisplay.getServerName();
7795    
7796                                                    if (Validator.isNull(virtualHostname) ||
7797                                                            StringUtil.equalsIgnoreCase(
7798                                                                    virtualHostname, _LOCALHOST)) {
7799    
7800                                                            virtualHostname = curLayoutSet.getVirtualHostname();
7801                                                    }
7802                                            }
7803    
7804                                            if (Validator.isNull(virtualHostname) ||
7805                                                    StringUtil.equalsIgnoreCase(
7806                                                            virtualHostname, _LOCALHOST)) {
7807    
7808                                                    Company company = themeDisplay.getCompany();
7809    
7810                                                    virtualHostname = company.getVirtualHostname();
7811                                            }
7812    
7813                                            if (canonicalURL ||
7814                                                    !StringUtil.equalsIgnoreCase(
7815                                                            virtualHostname, _LOCALHOST)) {
7816    
7817                                                    virtualHostname = getCanonicalDomain(
7818                                                            virtualHostname, portalDomain);
7819    
7820                                                    portalURL = getPortalURL(
7821                                                            virtualHostname, themeDisplay.getServerPort(),
7822                                                            themeDisplay.isSecure());
7823                                            }
7824                                    }
7825                            }
7826                    }
7827    
7828                    String friendlyURL = null;
7829    
7830                    if (privateLayoutSet) {
7831                            if (group.isUser()) {
7832                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7833                            }
7834                            else {
7835                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7836                            }
7837                    }
7838                    else {
7839                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7840                    }
7841    
7842                    StringBundler sb = new StringBundler(6);
7843    
7844                    sb.append(portalURL);
7845                    sb.append(_pathContext);
7846    
7847                    if (themeDisplay.isI18n() && !canonicalURL) {
7848                            sb.append(themeDisplay.getI18nPath());
7849                    }
7850    
7851                    if (themeDisplay.isWidget()) {
7852                            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7853                    }
7854    
7855                    sb.append(friendlyURL);
7856                    sb.append(group.getFriendlyURL());
7857    
7858                    return sb.toString();
7859            }
7860    
7861            protected String[] getGroupPermissions(
7862                    String[] groupPermissions, String className,
7863                    String inputPermissionsShowOptions) {
7864    
7865                    if ((groupPermissions != null) ||
7866                            (inputPermissionsShowOptions != null)) {
7867    
7868                            return groupPermissions;
7869                    }
7870    
7871                    List<String> groupDefaultActions =
7872                            ResourceActionsUtil.getModelResourceGroupDefaultActions(className);
7873    
7874                    return groupDefaultActions.toArray(
7875                            new String[groupDefaultActions.size()]);
7876            }
7877    
7878            protected String[] getGuestPermissions(
7879                    String[] guestPermissions, String className,
7880                    String inputPermissionsShowOptions) {
7881    
7882                    if ((guestPermissions != null) ||
7883                            (inputPermissionsShowOptions != null)) {
7884    
7885                            return guestPermissions;
7886                    }
7887    
7888                    List<String> guestDefaultActions =
7889                            ResourceActionsUtil.getModelResourceGuestDefaultActions(className);
7890    
7891                    return guestDefaultActions.toArray(
7892                            new String[guestDefaultActions.size()]);
7893            }
7894    
7895            protected String getPortletParam(HttpServletRequest request, String name) {
7896                    String portletId = ParamUtil.getString(request, "p_p_id");
7897    
7898                    if (Validator.isNull(portletId)) {
7899                            return StringPool.BLANK;
7900                    }
7901    
7902                    String value = null;
7903    
7904                    int valueCount = 0;
7905    
7906                    String keyName = StringPool.UNDERLINE.concat(name);
7907    
7908                    Map<String, String[]> parameterMap = request.getParameterMap();
7909    
7910                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7911                            String parameterName = entry.getKey();
7912    
7913                            int pos = parameterName.indexOf(keyName);
7914    
7915                            if (pos == -1) {
7916                                    continue;
7917                            }
7918    
7919                            valueCount++;
7920    
7921                            // There should never be more than one value
7922    
7923                            if (valueCount > 1) {
7924                                    return StringPool.BLANK;
7925                            }
7926    
7927                            String[] parameterValues = entry.getValue();
7928    
7929                            if (ArrayUtil.isEmpty(parameterValues) ||
7930                                    Validator.isNull(parameterValues[0])) {
7931    
7932                                    continue;
7933                            }
7934    
7935                            // The Struts action must be for the correct portlet
7936    
7937                            String portletId1 = parameterName.substring(1, pos);
7938    
7939                            if (portletId.equals(portletId1)) {
7940                                    value = parameterValues[0];
7941                            }
7942                    }
7943    
7944                    if (value == null) {
7945                            value = StringPool.BLANK;
7946                    }
7947    
7948                    return value;
7949            }
7950    
7951            protected String getServletURL(
7952                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7953                    throws PortalException, SystemException {
7954    
7955                    Layout layout = themeDisplay.getLayout();
7956    
7957                    StringBundler sb = new StringBundler();
7958    
7959                    sb.append(themeDisplay.getPortalURL());
7960    
7961                    if (Validator.isNotNull(_pathContext)) {
7962                            sb.append(_pathContext);
7963                    }
7964    
7965                    if (themeDisplay.isI18n()) {
7966                            sb.append(themeDisplay.getI18nPath());
7967                    }
7968    
7969                    sb.append(servletPath);
7970    
7971                    Group group = layout.getGroup();
7972    
7973                    if (layout.isPrivateLayout()) {
7974                            if (group.isUser()) {
7975                                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7976                            }
7977                            else {
7978                                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7979                            }
7980                    }
7981                    else {
7982                            sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7983                    }
7984    
7985                    sb.append(group.getFriendlyURL());
7986                    sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7987    
7988                    sb.append(FRIENDLY_URL_SEPARATOR);
7989    
7990                    FriendlyURLMapper friendlyURLMapper =
7991                            portlet.getFriendlyURLMapperInstance();
7992    
7993                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7994                            sb.append(friendlyURLMapper.getMapping());
7995                    }
7996                    else {
7997                            sb.append(portlet.getPortletId());
7998                    }
7999    
8000                    return sb.toString();
8001            }
8002    
8003            public String getVirtualHostname(LayoutSet layoutSet) {
8004                    String virtualHostname = layoutSet.getVirtualHostname();
8005    
8006                    if (Validator.isNull(virtualHostname)) {
8007                            virtualHostname = layoutSet.getCompanyFallbackVirtualHostname();
8008                    }
8009    
8010                    return virtualHostname;
8011            }
8012    
8013            protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
8014                    throws Exception {
8015    
8016                    String ticketKey = ParamUtil.getString(request, "ticketKey");
8017    
8018                    if (Validator.isNull(ticketKey)) {
8019                            return false;
8020                    }
8021    
8022                    Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
8023    
8024                    if ((ticket == null) ||
8025                            (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
8026    
8027                            return false;
8028                    }
8029    
8030                    String className = ticket.getClassName();
8031    
8032                    if (!className.equals(User.class.getName())) {
8033                            return false;
8034                    }
8035    
8036                    long doAsUserId = 0;
8037    
8038                    try {
8039                            Company company = getCompany(request);
8040    
8041                            String doAsUserIdString = ParamUtil.getString(
8042                                    request, "doAsUserId");
8043    
8044                            if (Validator.isNotNull(doAsUserIdString)) {
8045                                    doAsUserId = GetterUtil.getLong(
8046                                            Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
8047                            }
8048                    }
8049                    catch (Exception e) {
8050                            return false;
8051                    }
8052    
8053                    if (ticket.getClassPK() != doAsUserId) {
8054                            return false;
8055                    }
8056    
8057                    if (ticket.isExpired()) {
8058                            TicketLocalServiceUtil.deleteTicket(ticket);
8059    
8060                            return false;
8061                    }
8062    
8063                    Date expirationDate = new Date(
8064                            System.currentTimeMillis() +
8065                                    PropsValues.SESSION_TIMEOUT * Time.MINUTE);
8066    
8067                    ticket.setExpirationDate(expirationDate);
8068    
8069                    TicketLocalServiceUtil.updateTicket(ticket);
8070    
8071                    return true;
8072            }
8073    
8074            /**
8075             * @deprecated As of 6.2.0 with no direct replacement
8076             */
8077            protected boolean isPanelSelectedPortlet(
8078                    ThemeDisplay themeDisplay, String portletId) {
8079    
8080                    Layout layout = themeDisplay.getLayout();
8081    
8082                    String panelSelectedPortlets = layout.getTypeSettingsProperty(
8083                            "panelSelectedPortlets");
8084    
8085                    if (Validator.isNotNull(panelSelectedPortlets)) {
8086                            String[] panelSelectedPortletsArray = StringUtil.split(
8087                                    panelSelectedPortlets);
8088    
8089                            return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
8090                    }
8091    
8092                    return false;
8093            }
8094    
8095            protected boolean isUnwrapRequest(String currentRequestClassName) {
8096                    for (String packageName : PropsValues.REQUEST_UNWRAP_PACKAGES) {
8097                            if (currentRequestClassName.startsWith(packageName)) {
8098                                    return true;
8099                            }
8100                    }
8101    
8102                    return false;
8103            }
8104    
8105            protected boolean isValidPortalDomain(long companyId, String domain) {
8106                    if (_validPortalDomainCheckDisabled) {
8107                            return true;
8108                    }
8109    
8110                    if (!Validator.isHostName(domain)) {
8111                            return false;
8112                    }
8113    
8114                    for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
8115                            if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
8116                                    StringUtil.wildcardMatches(
8117                                            domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
8118                                            CharPool.PERCENT, false)) {
8119    
8120                                    return true;
8121                            }
8122                    }
8123    
8124                    if (StringUtil.equalsIgnoreCase(domain, PropsValues.WEB_SERVER_HOST)) {
8125                            return true;
8126                    }
8127    
8128                    if (isValidVirtualHostname(domain)) {
8129                            return true;
8130                    }
8131    
8132                    if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttp(companyId))) {
8133                            return true;
8134                    }
8135    
8136                    if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttps(companyId))) {
8137                            return true;
8138                    }
8139    
8140                    return false;
8141            }
8142    
8143            protected boolean isValidPortalDomain(String domain) {
8144                    long companyId = CompanyThreadLocal.getCompanyId();
8145    
8146                    return isValidPortalDomain(companyId, domain);
8147            }
8148    
8149            protected boolean isValidVirtualHostname(String virtualHostname) {
8150                    try {
8151                            virtualHostname = StringUtil.toLowerCase(virtualHostname.trim());
8152    
8153                            VirtualHost virtualHost =
8154                                    VirtualHostLocalServiceUtil.fetchVirtualHost(virtualHostname);
8155    
8156                            if (virtualHost != null) {
8157                                    return true;
8158                            }
8159                    }
8160                    catch (Exception e) {
8161                    }
8162    
8163                    return false;
8164            }
8165    
8166            protected void notifyPortalPortEventListeners(int portalPort) {
8167                    for (PortalPortEventListener portalPortEventListener :
8168                                    _portalPortEventListeners) {
8169    
8170                            portalPortEventListener.portalPortConfigured(portalPort);
8171                    }
8172            }
8173    
8174            protected void notifyPortalPortProtocolEventListeners(
8175                    int portalPort, Boolean secure) {
8176    
8177                    for (PortalPortProtocolEventListener portalPortProtocolEventListener :
8178                                    _portalPortProtocolEventListeners) {
8179    
8180                            portalPortProtocolEventListener.portalPortProtocolConfigured(
8181                                    portalPort, secure);
8182                    }
8183            }
8184    
8185            protected String removeRedirectParameter(String url) {
8186                    String queryString = HttpUtil.getQueryString(url);
8187    
8188                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
8189                            queryString);
8190    
8191                    for (String parameter : parameterMap.keySet()) {
8192                            if (parameter.endsWith("redirect")) {
8193                                    url = HttpUtil.removeParameter(url, parameter);
8194                            }
8195                    }
8196    
8197                    return url;
8198            }
8199    
8200            protected void resetThemeDisplayI18n(
8201                    ThemeDisplay themeDisplay, String languageId, String path,
8202                    Locale locale) {
8203    
8204                    themeDisplay.setI18nLanguageId(languageId);
8205                    themeDisplay.setI18nPath(path);
8206                    themeDisplay.setLocale(locale);
8207            }
8208    
8209            protected void setLocale(
8210                    HttpServletRequest request, HttpServletResponse response,
8211                    Locale locale) {
8212    
8213                    HttpSession session = request.getSession();
8214    
8215                    session.setAttribute(Globals.LOCALE_KEY, locale);
8216    
8217                    LanguageUtil.updateCookie(request, response, locale);
8218            }
8219    
8220            protected void setThemeDisplayI18n(
8221                    ThemeDisplay themeDisplay, Locale locale) {
8222    
8223                    String i18nLanguageId = null;
8224                    String i18nPath = null;
8225    
8226                    if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
8227                             ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
8228                              !locale.equals(LocaleUtil.getDefault()))) ||
8229                            (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
8230    
8231                            i18nLanguageId = locale.toString();
8232                            i18nPath = buildI18NPath(locale);
8233                    }
8234    
8235                    themeDisplay.setI18nLanguageId(i18nLanguageId);
8236                    themeDisplay.setI18nPath(i18nPath);
8237                    themeDisplay.setLocale(locale);
8238            }
8239    
8240            private static final String _J_SECURITY_CHECK = "j_security_check";
8241    
8242            private static final String _LOCALHOST = "localhost";
8243    
8244            private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
8245                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
8246    
8247            private static final String _PRIVATE_USER_SERVLET_MAPPING =
8248                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
8249    
8250            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
8251                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
8252    
8253            private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
8254    
8255            private static Log _logWebServerServlet = LogFactoryUtil.getLog(
8256                    WebServerServlet.class);
8257    
8258            private static Map<Long, String> _cdnHostHttpMap =
8259                    new ConcurrentHashMap<Long, String>();
8260            private static Map<Long, String> _cdnHostHttpsMap =
8261                    new ConcurrentHashMap<Long, String>();
8262            private static MethodHandler _resetCDNHostsMethodHandler =
8263                    new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
8264            private static Date _upTime = new Date();
8265    
8266            private String[] _allSystemGroups;
8267            private String[] _allSystemOrganizationRoles;
8268            private String[] _allSystemRoles;
8269            private String[] _allSystemSiteRoles;
8270            private Pattern _bannedResourceIdPattern = Pattern.compile(
8271                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
8272                    Pattern.CASE_INSENSITIVE);
8273            private String _computerAddress;
8274            private Set<String> _computerAddresses = new HashSet<String>();
8275            private String _computerName;
8276            private String[] _customSqlKeys;
8277            private String[] _customSqlValues;
8278            private EditDiscussionAction _editDiscussionAction =
8279                    new EditDiscussionAction();
8280            private String _pathContext;
8281            private String _pathFriendlyURLPrivateGroup;
8282            private String _pathFriendlyURLPrivateUser;
8283            private String _pathFriendlyURLPublic;
8284            private String _pathImage;
8285            private String _pathMain;
8286            private String _pathModule;
8287            private String _pathProxy;
8288            private Map<String, Long> _plidToPortletIdMap =
8289                    new ConcurrentHashMap<String, Long>();
8290            private final AtomicInteger _portalPort = new AtomicInteger(-1);
8291            private List<PortalPortEventListener> _portalPortEventListeners =
8292                    new ArrayList<PortalPortEventListener>();
8293            private List<PortalPortProtocolEventListener>
8294                            _portalPortProtocolEventListeners =
8295                                    new ArrayList<PortalPortProtocolEventListener>();
8296            private Set<String> _reservedParams;
8297            private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
8298            private final String _servletContextName;
8299            private String[] _sortedSystemGroups;
8300            private String[] _sortedSystemOrganizationRoles;
8301            private String[] _sortedSystemRoles;
8302            private String[] _sortedSystemSiteRoles;
8303            private boolean _validPortalDomainCheckDisabled;
8304    
8305    }