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