1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.util;
16  
17  import com.liferay.portal.NoSuchCompanyException;
18  import com.liferay.portal.NoSuchImageException;
19  import com.liferay.portal.NoSuchLayoutException;
20  import com.liferay.portal.NoSuchResourceException;
21  import com.liferay.portal.NoSuchUserException;
22  import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
23  import com.liferay.portal.kernel.dao.db.DB;
24  import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
25  import com.liferay.portal.kernel.exception.PortalException;
26  import com.liferay.portal.kernel.exception.SystemException;
27  import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
28  import com.liferay.portal.kernel.language.LanguageUtil;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
32  import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
33  import com.liferay.portal.kernel.portlet.LiferayPortletMode;
34  import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
35  import com.liferay.portal.kernel.portlet.LiferayWindowState;
36  import com.liferay.portal.kernel.portlet.PortletBag;
37  import com.liferay.portal.kernel.portlet.PortletBagPool;
38  import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
39  import com.liferay.portal.kernel.servlet.HttpHeaders;
40  import com.liferay.portal.kernel.servlet.HttpMethods;
41  import com.liferay.portal.kernel.servlet.PipingServletResponse;
42  import com.liferay.portal.kernel.servlet.ServletContextUtil;
43  import com.liferay.portal.kernel.servlet.SessionErrors;
44  import com.liferay.portal.kernel.servlet.StringServletResponse;
45  import com.liferay.portal.kernel.servlet.WebDirDetector;
46  import com.liferay.portal.kernel.upload.UploadPortletRequest;
47  import com.liferay.portal.kernel.upload.UploadServletRequest;
48  import com.liferay.portal.kernel.util.ArrayUtil;
49  import com.liferay.portal.kernel.util.Base64;
50  import com.liferay.portal.kernel.util.CalendarFactoryUtil;
51  import com.liferay.portal.kernel.util.CharPool;
52  import com.liferay.portal.kernel.util.ClassUtil;
53  import com.liferay.portal.kernel.util.ContentTypes;
54  import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
55  import com.liferay.portal.kernel.util.GetterUtil;
56  import com.liferay.portal.kernel.util.HtmlUtil;
57  import com.liferay.portal.kernel.util.Http;
58  import com.liferay.portal.kernel.util.HttpUtil;
59  import com.liferay.portal.kernel.util.JavaConstants;
60  import com.liferay.portal.kernel.util.KeyValuePair;
61  import com.liferay.portal.kernel.util.LocaleUtil;
62  import com.liferay.portal.kernel.util.ParamUtil;
63  import com.liferay.portal.kernel.util.PropsKeys;
64  import com.liferay.portal.kernel.util.ReleaseInfo;
65  import com.liferay.portal.kernel.util.SetUtil;
66  import com.liferay.portal.kernel.util.StringBundler;
67  import com.liferay.portal.kernel.util.StringComparator;
68  import com.liferay.portal.kernel.util.StringPool;
69  import com.liferay.portal.kernel.util.StringUtil;
70  import com.liferay.portal.kernel.util.UnicodeProperties;
71  import com.liferay.portal.kernel.util.Validator;
72  import com.liferay.portal.kernel.xml.QName;
73  import com.liferay.portal.model.BaseModel;
74  import com.liferay.portal.model.ClassName;
75  import com.liferay.portal.model.ColorScheme;
76  import com.liferay.portal.model.Company;
77  import com.liferay.portal.model.CompanyConstants;
78  import com.liferay.portal.model.Group;
79  import com.liferay.portal.model.GroupConstants;
80  import com.liferay.portal.model.Layout;
81  import com.liferay.portal.model.LayoutConstants;
82  import com.liferay.portal.model.LayoutSet;
83  import com.liferay.portal.model.LayoutTypePortlet;
84  import com.liferay.portal.model.Organization;
85  import com.liferay.portal.model.Portlet;
86  import com.liferay.portal.model.PublicRenderParameter;
87  import com.liferay.portal.model.Resource;
88  import com.liferay.portal.model.ResourceCode;
89  import com.liferay.portal.model.ResourceConstants;
90  import com.liferay.portal.model.ResourcePermission;
91  import com.liferay.portal.model.Role;
92  import com.liferay.portal.model.RoleConstants;
93  import com.liferay.portal.model.Theme;
94  import com.liferay.portal.model.User;
95  import com.liferay.portal.model.UserGroup;
96  import com.liferay.portal.plugin.PluginPackageUtil;
97  import com.liferay.portal.security.auth.AuthTokenUtil;
98  import com.liferay.portal.security.auth.PrincipalException;
99  import com.liferay.portal.security.permission.ActionKeys;
100 import com.liferay.portal.security.permission.PermissionChecker;
101 import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
102 import com.liferay.portal.security.permission.ResourceActionsUtil;
103 import com.liferay.portal.service.ClassNameLocalServiceUtil;
104 import com.liferay.portal.service.CompanyLocalServiceUtil;
105 import com.liferay.portal.service.GroupLocalServiceUtil;
106 import com.liferay.portal.service.LayoutLocalServiceUtil;
107 import com.liferay.portal.service.PortletLocalServiceUtil;
108 import com.liferay.portal.service.ResourceCodeLocalServiceUtil;
109 import com.liferay.portal.service.ResourceLocalServiceUtil;
110 import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
111 import com.liferay.portal.service.UserLocalServiceUtil;
112 import com.liferay.portal.service.UserServiceUtil;
113 import com.liferay.portal.service.permission.GroupPermissionUtil;
114 import com.liferay.portal.service.permission.LayoutPermissionUtil;
115 import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
116 import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
117 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
118 import com.liferay.portal.service.permission.PortletPermissionUtil;
119 import com.liferay.portal.service.permission.UserPermissionUtil;
120 import com.liferay.portal.servlet.ImageServlet;
121 import com.liferay.portal.servlet.filters.i18n.I18nFilter;
122 import com.liferay.portal.struts.StrutsUtil;
123 import com.liferay.portal.theme.ThemeDisplay;
124 import com.liferay.portal.upload.UploadPortletRequestImpl;
125 import com.liferay.portal.upload.UploadServletRequestImpl;
126 import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
127 import com.liferay.portlet.ActionResponseImpl;
128 import com.liferay.portlet.ControlPanelEntry;
129 import com.liferay.portlet.DefaultControlPanelEntryFactory;
130 import com.liferay.portlet.PortletConfigFactory;
131 import com.liferay.portlet.PortletConfigImpl;
132 import com.liferay.portlet.PortletContextImpl;
133 import com.liferay.portlet.PortletPreferencesFactoryUtil;
134 import com.liferay.portlet.PortletPreferencesImpl;
135 import com.liferay.portlet.PortletPreferencesWrapper;
136 import com.liferay.portlet.PortletQNameUtil;
137 import com.liferay.portlet.PortletRequestImpl;
138 import com.liferay.portlet.PortletResponseImpl;
139 import com.liferay.portlet.PortletURLImpl;
140 import com.liferay.portlet.RenderRequestImpl;
141 import com.liferay.portlet.RenderResponseImpl;
142 import com.liferay.portlet.UserAttributes;
143 import com.liferay.portlet.admin.util.OmniadminUtil;
144 import com.liferay.portlet.blogs.model.BlogsEntry;
145 import com.liferay.portlet.bookmarks.model.BookmarksEntry;
146 import com.liferay.portlet.calendar.model.CalEvent;
147 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
148 import com.liferay.portlet.expando.action.EditExpandoAction;
149 import com.liferay.portlet.expando.model.ExpandoBridge;
150 import com.liferay.portlet.imagegallery.model.IGImage;
151 import com.liferay.portlet.messageboards.model.MBMessage;
152 import com.liferay.portlet.social.model.SocialEquityActionMapping;
153 import com.liferay.portlet.social.util.FacebookUtil;
154 import com.liferay.portlet.wiki.model.WikiPage;
155 import com.liferay.util.Encryptor;
156 import com.liferay.util.JS;
157 import com.liferay.util.PwdGenerator;
158 import com.liferay.util.UniqueList;
159 import com.liferay.util.servlet.DynamicServletRequest;
160 
161 import java.io.File;
162 import java.io.IOException;
163 import java.io.Serializable;
164 
165 import java.lang.reflect.Method;
166 
167 import java.net.InetAddress;
168 import java.net.UnknownHostException;
169 
170 import java.util.ArrayList;
171 import java.util.Arrays;
172 import java.util.Calendar;
173 import java.util.Date;
174 import java.util.Enumeration;
175 import java.util.HashMap;
176 import java.util.HashSet;
177 import java.util.Iterator;
178 import java.util.List;
179 import java.util.Locale;
180 import java.util.Map;
181 import java.util.Properties;
182 import java.util.ResourceBundle;
183 import java.util.Set;
184 import java.util.TimeZone;
185 import java.util.TreeSet;
186 import java.util.concurrent.ConcurrentHashMap;
187 import java.util.concurrent.locks.Lock;
188 import java.util.concurrent.locks.ReentrantLock;
189 
190 import javax.portlet.ActionRequest;
191 import javax.portlet.ActionResponse;
192 import javax.portlet.PortletConfig;
193 import javax.portlet.PortletMode;
194 import javax.portlet.PortletPreferences;
195 import javax.portlet.PortletRequest;
196 import javax.portlet.PortletResponse;
197 import javax.portlet.PortletURL;
198 import javax.portlet.PreferencesValidator;
199 import javax.portlet.RenderRequest;
200 import javax.portlet.RenderResponse;
201 import javax.portlet.ValidatorException;
202 import javax.portlet.WindowState;
203 
204 import javax.servlet.RequestDispatcher;
205 import javax.servlet.ServletContext;
206 import javax.servlet.ServletException;
207 import javax.servlet.http.HttpServletRequest;
208 import javax.servlet.http.HttpServletRequestWrapper;
209 import javax.servlet.http.HttpServletResponse;
210 import javax.servlet.http.HttpSession;
211 import javax.servlet.jsp.PageContext;
212 
213 import org.apache.struts.Globals;
214 
215 /**
216  * <a href="PortalImpl.java.html"><b><i>View Source</i></b></a>
217  *
218  * @author Brian Wing Shun Chan
219  * @author Brian Myunghun Kim
220  * @author Jorge Ferrer
221  * @author Raymond Augé
222  * @author Eduardo Lundgren
223  * @author Wesley Gong
224  */
225 public class PortalImpl implements Portal {
226 
227     public PortalImpl() {
228 
229         // Computer name
230 
231         _computerName = System.getProperty("env.COMPUTERNAME");
232 
233         if (Validator.isNull(_computerName)) {
234             _computerName = System.getProperty("env.HOST");
235         }
236 
237         if (Validator.isNull(_computerName)) {
238             _computerName = System.getProperty("env.HOSTNAME");
239         }
240 
241         if (Validator.isNull(_computerName)) {
242             try {
243                 _computerName = InetAddress.getLocalHost().getHostName();
244             }
245             catch (UnknownHostException uhe) {
246             }
247         }
248 
249         try {
250             _computerAddress = InetAddress.getByName(
251                 _computerName).getHostAddress();
252         }
253         catch (UnknownHostException uhe) {
254         }
255 
256         if (Validator.isNull(_computerAddress)) {
257             try {
258                 _computerAddress = InetAddress.getLocalHost().getHostAddress();
259             }
260             catch (UnknownHostException uhe) {
261             }
262         }
263 
264         // Global lib directory
265 
266         _globalLibDir = ClassUtil.getParentPath(
267             ReleaseInfo.class.getClassLoader(), ReleaseInfo.class.getName());
268 
269         int pos = _globalLibDir.lastIndexOf(".jar!");
270 
271         pos = _globalLibDir.lastIndexOf(StringPool.SLASH, pos);
272 
273         _globalLibDir = _globalLibDir.substring(0, pos + 1);
274 
275         if (_log.isInfoEnabled()) {
276             _log.info("Global lib directory " + _globalLibDir);
277         }
278 
279         // Portal lib directory
280 
281         ClassLoader classLoader = getClass().getClassLoader();
282 
283         _portalLibDir = WebDirDetector.getLibDir(classLoader);
284 
285         String portalLibDir = System.getProperty("liferay.lib.portal.dir");
286 
287         if (portalLibDir != null) {
288             if (!portalLibDir.endsWith(StringPool.SLASH)) {
289                 portalLibDir += StringPool.SLASH;
290             }
291 
292             _portalLibDir = portalLibDir;
293         }
294 
295         if (_log.isInfoEnabled()) {
296             _log.info("Portal lib directory " + _portalLibDir);
297         }
298 
299         _portalWebDir = WebDirDetector.getRootDir(_portalLibDir);
300 
301         if (_log.isDebugEnabled()) {
302             _log.debug("Portal web directory " + _portalWebDir);
303         }
304 
305         // CDN host
306 
307         _cdnHostHttp = PropsValues.CDN_HOST_HTTP;
308 
309         if (_cdnHostHttp.startsWith("${")) {
310             _cdnHostHttp = StringPool.BLANK;
311         }
312 
313         _cdnHostHttps = PropsValues.CDN_HOST_HTTPS;
314 
315         if (_cdnHostHttps.startsWith("${")) {
316             _cdnHostHttps = StringPool.BLANK;
317         }
318 
319         // Paths
320 
321         _pathContext = PropsUtil.get(PropsKeys.PORTAL_CTX);
322 
323         if (_pathContext.equals(StringPool.SLASH)) {
324             _pathContext = StringPool.BLANK;
325         }
326 
327         _pathFriendlyURLPrivateGroup =
328             _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
329         _pathFriendlyURLPrivateUser =
330             _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
331         _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
332         _pathImage = _pathContext + PATH_IMAGE;
333         _pathMain = _pathContext + PATH_MAIN;
334 
335         // Groups
336 
337         String customSystemGroups[] =
338             PropsUtil.getArray(PropsKeys.SYSTEM_GROUPS);
339 
340         if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
341             _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
342         }
343         else {
344             _allSystemGroups = ArrayUtil.append(
345                 GroupConstants.SYSTEM_GROUPS, customSystemGroups);
346         }
347 
348         _sortedSystemGroups = new String[_allSystemGroups.length];
349 
350         System.arraycopy(
351             _allSystemGroups, 0, _sortedSystemGroups, 0,
352             _allSystemGroups.length);
353 
354         Arrays.sort(_sortedSystemGroups, new StringComparator());
355 
356         // Regular roles
357 
358         String customSystemRoles[] = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
359 
360         if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
361             _allSystemRoles = RoleConstants.SYSTEM_ROLES;
362         }
363         else {
364             _allSystemRoles = ArrayUtil.append(
365                 RoleConstants.SYSTEM_ROLES, customSystemRoles);
366         }
367 
368         _sortedSystemRoles = new String[_allSystemRoles.length];
369 
370         System.arraycopy(
371             _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
372 
373         Arrays.sort(_sortedSystemRoles, new StringComparator());
374 
375         // Community roles
376 
377         String customSystemCommunityRoles[] =
378             PropsUtil.getArray(PropsKeys.SYSTEM_COMMUNITY_ROLES);
379 
380         if ((customSystemCommunityRoles == null) ||
381             (customSystemCommunityRoles.length == 0)) {
382 
383             _allSystemCommunityRoles = RoleConstants.SYSTEM_COMMUNITY_ROLES;
384         }
385         else {
386             _allSystemCommunityRoles = ArrayUtil.append(
387                 RoleConstants.SYSTEM_COMMUNITY_ROLES,
388                 customSystemCommunityRoles);
389         }
390 
391         _sortedSystemCommunityRoles =
392             new String[_allSystemCommunityRoles.length];
393 
394         System.arraycopy(
395             _allSystemCommunityRoles, 0, _sortedSystemCommunityRoles, 0,
396                 _allSystemCommunityRoles.length);
397 
398         Arrays.sort(_sortedSystemCommunityRoles, new StringComparator());
399 
400         // Organization Roles
401 
402         String customSystemOrganizationRoles[] =
403             PropsUtil.getArray(PropsKeys.SYSTEM_ORGANIZATION_ROLES);
404 
405         if ((customSystemOrganizationRoles == null) ||
406             (customSystemOrganizationRoles.length == 0)) {
407 
408             _allSystemOrganizationRoles =
409                 RoleConstants.SYSTEM_ORGANIZATION_ROLES;
410         }
411         else {
412             _allSystemOrganizationRoles = ArrayUtil.append(
413                 RoleConstants.SYSTEM_ORGANIZATION_ROLES,
414                 customSystemOrganizationRoles);
415         }
416 
417         _sortedSystemOrganizationRoles =
418             new String[_allSystemOrganizationRoles.length];
419 
420         System.arraycopy(
421             _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
422                 _allSystemOrganizationRoles.length);
423 
424         Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
425 
426         // Portlet add default resource check white list
427 
428         _portletAddDefaultResourceCheckWhitelist = SetUtil.fromArray(
429             PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST);
430         _portletAddDefaultResourceCheckWhitelistActions = SetUtil.fromArray(
431             PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS);
432 
433         // Reserved parameter names
434 
435         _reservedParams = new HashSet<String>();
436 
437         _reservedParams.add("p_auth");
438         _reservedParams.add("p_l_id");
439         _reservedParams.add("p_l_reset");
440         _reservedParams.add("p_p_auth");
441         _reservedParams.add("p_p_id");
442         _reservedParams.add("p_p_lifecycle");
443         _reservedParams.add("p_p_url_type");
444         _reservedParams.add("p_p_state");
445         _reservedParams.add("p_p_mode");
446         _reservedParams.add("p_p_resource_id");
447         _reservedParams.add("p_p_cacheability");
448         _reservedParams.add("p_p_width");
449         _reservedParams.add("p_p_col_id");
450         _reservedParams.add("p_p_col_pos");
451         _reservedParams.add("p_p_col_count");
452         _reservedParams.add("p_p_static");
453         _reservedParams.add("p_p_static");
454         _reservedParams.add("p_p_isolated");
455         _reservedParams.add("saveLastPath");
456         _reservedParams.add("scroll");
457     }
458 
459     /**
460      * Adds the description for a page. This appends to the existing page
461      * description.
462      */
463     public void addPageDescription(
464         String description, HttpServletRequest request) {
465 
466         String requestDescription = (String)request.getAttribute(
467             WebKeys.PAGE_DESCRIPTION);
468 
469         if (requestDescription != null) {
470             description = requestDescription + StringPool.SPACE + description;
471         }
472 
473         request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
474     }
475 
476     /**
477      * Adds the keywords for a page. This appends to the existing page keywords.
478      */
479     public void addPageKeywords(String keywords, HttpServletRequest request) {
480         List<String> requestKeywords = (List<String>)request.getAttribute(
481             WebKeys.PAGE_KEYWORDS);
482 
483         if (requestKeywords == null) {
484             requestKeywords = new UniqueList<String>();
485         }
486 
487         String[] keywordsArray = StringUtil.split(keywords);
488 
489         for (String keyword : keywordsArray) {
490             if (!requestKeywords.contains(keyword.toLowerCase())) {
491                 requestKeywords.add(keyword.toLowerCase());
492             }
493         }
494 
495         request.setAttribute(WebKeys.PAGE_KEYWORDS, requestKeywords);
496     }
497 
498     /**
499      * Adds the subtitle for a page. This appends to the existing page subtitle.
500      */
501     public void addPageSubtitle(String subtitle, HttpServletRequest request) {
502         String requestSubtitle = (String)request.getAttribute(
503             WebKeys.PAGE_SUBTITLE);
504 
505         if (requestSubtitle != null) {
506             subtitle = requestSubtitle + StringPool.SPACE + subtitle;
507         }
508 
509         request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
510     }
511 
512     /**
513      * Adds the whole title for a page. This appends to the existing page whole
514      * title.
515      */
516     public void addPageTitle(String title, HttpServletRequest request) {
517         String requestTitle = (String)request.getAttribute(WebKeys.PAGE_TITLE);
518 
519         if (requestTitle != null) {
520             title = requestTitle + StringPool.SPACE + title;
521         }
522 
523         request.setAttribute(WebKeys.PAGE_TITLE, title);
524     }
525 
526     public void addPortletBreadcrumbEntry(
527         HttpServletRequest request, String title, String url) {
528 
529         List<KeyValuePair> portletBreadcrumbList =
530             (List<KeyValuePair>)request.getAttribute(
531                 WebKeys.PORTLET_BREADCRUMB_MAP);
532 
533         if (portletBreadcrumbList == null) {
534             portletBreadcrumbList = new ArrayList<KeyValuePair>();
535 
536             request.setAttribute(
537                 WebKeys.PORTLET_BREADCRUMB_MAP, portletBreadcrumbList);
538         }
539 
540         portletBreadcrumbList.add(new KeyValuePair(title, url));
541     }
542 
543     public void addPortletDefaultResource(
544             HttpServletRequest request, Portlet portlet)
545         throws PortalException, SystemException {
546 
547         ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
548             WebKeys.THEME_DISPLAY);
549 
550         Layout layout = themeDisplay.getLayout();
551 
552         String rootPortletId = portlet.getRootPortletId();
553 
554         String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
555             layout.getPlid(), portlet.getPortletId());
556 
557         try {
558             if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
559                 int count =
560                     ResourcePermissionLocalServiceUtil.
561                         getResourcePermissionsCount(
562                             themeDisplay.getCompanyId(), rootPortletId,
563                             ResourceConstants.SCOPE_INDIVIDUAL,
564                             portletPrimaryKey);
565 
566                 if (count == 0) {
567                     throw new NoSuchResourceException();
568                 }
569             }
570             else if (!portlet.isUndeployedPortlet()) {
571                 ResourceLocalServiceUtil.getResource(
572                     themeDisplay.getCompanyId(), rootPortletId,
573                     ResourceConstants.SCOPE_INDIVIDUAL, portletPrimaryKey);
574             }
575         }
576         catch (NoSuchResourceException nsre) {
577             ResourceLocalServiceUtil.addResources(
578                 themeDisplay.getCompanyId(), layout.getGroupId(), 0,
579                 rootPortletId, portletPrimaryKey, true, true, true);
580         }
581     }
582 
583     public void clearRequestParameters(RenderRequest renderRequest) {
584 
585         // Clear the render parameters if they were set during processAction
586 
587         ThemeDisplay themeDisplay = (ThemeDisplay)renderRequest.getAttribute(
588             WebKeys.THEME_DISPLAY);
589 
590         if (themeDisplay.isLifecycleAction()) {
591             ((RenderRequestImpl)renderRequest).getRenderParameters().clear();
592         }
593     }
594 
595     public void copyRequestParameters(
596         ActionRequest actionRequest, ActionResponse actionResponse) {
597 
598         try {
599             ActionResponseImpl actionResponseImpl =
600                 (ActionResponseImpl)actionResponse;
601 
602             Map<String, String[]> renderParameters =
603                 actionResponseImpl.getRenderParameterMap();
604 
605             actionResponse.setRenderParameter("p_p_lifecycle", "1");
606 
607             Enumeration<String> enu = actionRequest.getParameterNames();
608 
609             while (enu.hasMoreElements()) {
610                 String param = enu.nextElement();
611                 String[] values = actionRequest.getParameterValues(param);
612 
613                 if (renderParameters.get(
614                         actionResponseImpl.getNamespace() + param) == null) {
615 
616                     actionResponse.setRenderParameter(param, values);
617                 }
618             }
619         }
620         catch (IllegalStateException ise) {
621 
622             // This should only happen if the developer called
623             // sendRedirect of javax.portlet.ActionResponse
624 
625         }
626     }
627 
628     public String escapeRedirect(String url) {
629         if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
630             return url;
631         }
632 
633         try {
634             String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
635 
636             String domain = StringUtil.split(
637                 HttpUtil.getDomain(url), StringPool.COLON)[0];
638 
639             if (securityMode.equals("domain")) {
640                 String[] allowedDomains =
641                     PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
642 
643                 if ((allowedDomains.length > 0) &&
644                     !ArrayUtil.contains(allowedDomains, domain)) {
645 
646                     if (_log.isDebugEnabled()) {
647                         _log.debug("Redirect URL " + url + " is not allowed");
648                     }
649 
650                     url = null;
651                 }
652             }
653             else if (securityMode.equals("ip")) {
654                 String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
655 
656                 InetAddress inetAddress = InetAddress.getByName(domain);
657 
658                 if ((allowedIps.length > 0) &&
659                     !ArrayUtil.contains(
660                         allowedIps, inetAddress.getHostAddress())) {
661 
662                     String serverIp = getComputerAddress();
663 
664                     if (!serverIp.equals(inetAddress.getHostAddress()) ||
665                         !ArrayUtil.contains(allowedIps, "SERVER_IP")) {
666 
667                         if (_log.isDebugEnabled()) {
668                             _log.debug(
669                                 "Redirect URL " + url + " is not allowed");
670                         }
671 
672                         url = null;
673                     }
674                 }
675             }
676         }
677         catch (UnknownHostException uhe) {
678             if (_log.isDebugEnabled()) {
679                 _log.debug("Unable to determine IP for redirect URL " + url);
680             }
681 
682             url = null;
683         }
684 
685         return url;
686     }
687 
688     public String generateRandomKey(HttpServletRequest request, String input) {
689         ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
690             WebKeys.THEME_DISPLAY);
691 
692         if (themeDisplay.isLifecycleResource() ||
693             themeDisplay.isStateExclusive()) {
694 
695             return PwdGenerator.getPassword(PwdGenerator.KEY3, 4);
696         }
697         else {
698             return DeterminateKeyGenerator.generate(input);
699         }
700     }
701 
702     public BaseModel<?> getBaseModel(Resource resource)
703         throws PortalException, SystemException {
704 
705         ResourceCode resourceCode =
706             ResourceCodeLocalServiceUtil.getResourceCode(resource.getCodeId());
707 
708         String modelName = resourceCode.getName();
709         String primKey = resource.getPrimKey();
710 
711         return getBaseModel(modelName, primKey);
712     }
713 
714     public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
715         throws PortalException, SystemException {
716 
717         String modelName = resourcePermission.getName();
718         String primKey = resourcePermission.getPrimKey();
719 
720         return getBaseModel(modelName, primKey);
721     }
722 
723     public BaseModel<?> getBaseModel(String modelName, String primKey)
724         throws PortalException, SystemException {
725 
726         if (!modelName.contains(".model.")) {
727             return null;
728         }
729 
730         String[] parts = StringUtil.split(modelName, StringPool.PERIOD);
731 
732         if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
733             return null;
734         }
735 
736         parts[parts.length - 2] = "service";
737 
738         String serviceName =
739             StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
740         String methodName = "get" + parts[parts.length - 1];
741 
742         Method method = null;
743 
744         try {
745             Class<?> serviceUtil = Class.forName(serviceName);
746 
747             if (Validator.isNumber(primKey)) {
748                 method = serviceUtil.getMethod(
749                     methodName, new Class[] {Long.TYPE});
750 
751                 return (BaseModel<?>)method.invoke(null, new Long(primKey));
752             }
753             else {
754                 method = serviceUtil.getMethod(
755                     methodName, new Class[] {String.class});
756 
757                 return (BaseModel<?>)method.invoke(null, primKey);
758             }
759         }
760         catch (Exception e) {
761             Throwable cause = e.getCause();
762 
763             if (cause instanceof PortalException) {
764                 throw (PortalException)cause;
765             }
766             else if (cause instanceof SystemException) {
767                 throw (SystemException)cause;
768             }
769             else {
770                 throw new SystemException(cause);
771             }
772         }
773     }
774 
775     public long getBasicAuthUserId(HttpServletRequest request)
776         throws PortalException, SystemException {
777 
778         long companyId = PortalInstances.getCompanyId(request);
779 
780         return getBasicAuthUserId(request, companyId);
781     }
782 
783     public long getBasicAuthUserId(HttpServletRequest request, long companyId)
784         throws PortalException, SystemException {
785 
786         long userId = 0;
787 
788         String authorizationHeader = request.getHeader(
789             HttpHeaders.AUTHORIZATION);
790 
791         if (Validator.isNull(authorizationHeader)) {
792             return userId;
793         }
794 
795         String[] authorizationArray = authorizationHeader.split("\\s+");
796 
797         String authorization = authorizationArray[0];
798         String credentials = new String(Base64.decode(authorizationArray[1]));
799 
800         if (!authorization.equalsIgnoreCase(HttpServletRequest.BASIC_AUTH)) {
801             return userId;
802         }
803 
804         String[] loginAndPassword = StringUtil.split(
805             credentials, StringPool.COLON);
806 
807         String login = loginAndPassword[0].trim();
808 
809         String password = null;
810 
811         if (loginAndPassword.length > 1) {
812             password = loginAndPassword[1].trim();
813         }
814 
815         // Strip @uid and @sn for backwards compatibility
816 
817         if (login.endsWith("@uid")) {
818             int pos = login.indexOf("@uid");
819 
820             login = login.substring(0, pos);
821         }
822         else if (login.endsWith("@sn")) {
823             int pos = login.indexOf("@sn");
824 
825             login = login.substring(0, pos);
826         }
827 
828         // Try every authentication type
829 
830         userId = UserLocalServiceUtil.authenticateForBasic(
831             companyId, CompanyConstants.AUTH_TYPE_EA, login, password);
832 
833         if (userId > 0) {
834             return userId;
835         }
836 
837         userId = UserLocalServiceUtil.authenticateForBasic(
838             companyId, CompanyConstants.AUTH_TYPE_SN, login, password);
839 
840         if (userId > 0) {
841             return userId;
842         }
843 
844         userId = UserLocalServiceUtil.authenticateForBasic(
845             companyId, CompanyConstants.AUTH_TYPE_ID, login, password);
846 
847         return userId;
848     }
849 
850     /**
851      * @deprecated {@link #getCDNHost(boolean)}
852      */
853     public String getCDNHost() {
854         return getCDNHostHttp();
855     }
856 
857     public String getCDNHost(boolean secure) {
858         if (secure) {
859             return getCDNHostHttps();
860         }
861         else {
862             return getCDNHostHttp();
863         }
864     }
865 
866     public String getCDNHostHttp() {
867         return _cdnHostHttp;
868     }
869 
870     public String getCDNHostHttps() {
871         return _cdnHostHttps;
872     }
873 
874     public String getClassName(long classNameId) {
875         try {
876             ClassName className = ClassNameLocalServiceUtil.getClassName(
877                 classNameId);
878 
879             return className.getValue();
880         }
881         catch (Exception e) {
882             throw new RuntimeException(
883                 "Unable to get class name from id " + classNameId);
884         }
885     }
886 
887     public long getClassNameId(Class<?> classObj) {
888         return ClassNameLocalServiceUtil.getClassNameId(classObj);
889     }
890 
891     public long getClassNameId(String value) {
892         return ClassNameLocalServiceUtil.getClassNameId(value);
893     }
894 
895     public String getClassNamePortletId(String className) {
896         String portletId = StringPool.BLANK;
897 
898         if (className.startsWith("com.liferay.portlet.blogs")) {
899             portletId = PortletKeys.BLOGS;
900         }
901         else if (className.startsWith("com.liferay.portlet.bookmarks")) {
902             portletId = PortletKeys.BOOKMARKS;
903         }
904         else if (className.startsWith("com.liferay.portlet.calendar")) {
905             portletId = PortletKeys.CALENDAR;
906         }
907         else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
908             portletId = PortletKeys.DOCUMENT_LIBRARY;
909         }
910         else if (className.startsWith("com.liferay.portlet.imagegallery")) {
911             portletId = PortletKeys.IMAGE_GALLERY;
912         }
913         else if (className.startsWith("com.liferay.portlet.journal")) {
914             portletId = PortletKeys.JOURNAL;
915         }
916         else if (className.startsWith("com.liferay.portlet.messageboards")) {
917             portletId = PortletKeys.MESSAGE_BOARDS;
918         }
919         else if (className.startsWith("com.liferay.portlet.wiki")) {
920             portletId = PortletKeys.WIKI;
921         }
922 
923         return portletId;
924     }
925 
926     public String getCommunityLoginURL(ThemeDisplay themeDisplay)
927         throws PortalException, SystemException {
928 
929         if (Validator.isNull(PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
930             return null;
931         }
932 
933         for (Layout layout : themeDisplay.getLayouts()) {
934             if (layout.getFriendlyURL().equals(
935                     PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
936 
937                 if (themeDisplay.getLayout() != null) {
938                     String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
939                         themeDisplay.getLayout().getLayoutSet(), themeDisplay);
940 
941                     return layoutSetFriendlyURL +
942                         PropsValues.AUTH_LOGIN_COMMUNITY_URL;
943                 }
944 
945                 break;
946             }
947         }
948 
949         return null;
950     }
951 
952     public String[] getCommunityPermissions(HttpServletRequest request) {
953         return request.getParameterValues("communityPermissions");
954     }
955 
956     public String[] getCommunityPermissions(PortletRequest portletRequest) {
957         return portletRequest.getParameterValues("communityPermissions");
958     }
959 
960     public Company getCompany(HttpServletRequest request)
961         throws PortalException, SystemException {
962 
963         long companyId = getCompanyId(request);
964 
965         if (companyId <= 0) {
966             return null;
967         }
968 
969         Company company = (Company)request.getAttribute(WebKeys.COMPANY);
970 
971         if (company == null) {
972 
973             // LEP-5994
974 
975             try {
976                 company = CompanyLocalServiceUtil.getCompanyById(companyId);
977             }
978             catch (NoSuchCompanyException nsce) {
979                 company = CompanyLocalServiceUtil.getCompanyById(
980                     PortalInstances.getDefaultCompanyId());
981             }
982 
983             request.setAttribute(WebKeys.COMPANY, company);
984         }
985 
986         return company;
987     }
988 
989     public Company getCompany(PortletRequest portletRequest)
990         throws PortalException, SystemException {
991 
992         return getCompany(getHttpServletRequest(portletRequest));
993     }
994 
995     public long getCompanyId(HttpServletRequest request) {
996         return PortalInstances.getCompanyId(request);
997     }
998 
999     public long getCompanyId(PortletRequest portletRequest) {
1000        return getCompanyId(getHttpServletRequest(portletRequest));
1001    }
1002
1003    public long[] getCompanyIds() {
1004        return PortalInstances.getCompanyIds();
1005    }
1006
1007    public String getComputerAddress() {
1008        return _computerAddress;
1009    }
1010
1011    public String getComputerName() {
1012        return _computerName;
1013    }
1014
1015    public String getControlPanelCategory(
1016            String portletId, ThemeDisplay themeDisplay)
1017        throws SystemException {
1018
1019        for (String category : PortletCategoryKeys.ALL) {
1020            List<Portlet> portlets = getControlPanelPortlets(
1021                category, themeDisplay);
1022
1023            for (Portlet portlet : portlets) {
1024                if (portlet.getPortletId().equals(portletId)) {
1025                    return category;
1026                }
1027            }
1028        }
1029
1030        return StringPool.BLANK;
1031    }
1032
1033    public String getControlPanelFullURL(
1034            long scopeGroupId, String ppid, Map<String, String[]> params)
1035        throws PortalException, SystemException {
1036
1037        StringBundler sb = new StringBundler(6);
1038
1039        Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1040
1041        Company company = CompanyLocalServiceUtil.getCompany(
1042            group.getCompanyId());
1043
1044        sb.append(
1045            getPortalURL(company.getVirtualHost(), getPortalPort(), false));
1046        sb.append(PortalUtil.getPathFriendlyURLPrivateGroup());
1047        sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1048        sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1049
1050        if (params != null) {
1051            params = new HashMap<String, String[]>(params);
1052        }
1053        else {
1054            params = new HashMap<String, String[]>();
1055        }
1056
1057        params.put("p_p_id", new String[] {ppid});
1058        params.put("p_p_lifecycle", new String[] {"0"});
1059        params.put(
1060            "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1061        params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1062
1063        sb.append(HttpUtil.parameterMapToString(params, true));
1064
1065        return sb.toString();
1066    }
1067
1068    public List<Portlet> getControlPanelPortlets(
1069            String category, ThemeDisplay themeDisplay)
1070        throws SystemException {
1071
1072        Set<Portlet> portletsSet = new TreeSet<Portlet>(
1073            new PortletControlPanelWeightComparator());
1074
1075        List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1076            themeDisplay.getCompanyId());
1077
1078        for (Portlet portlet : portletsList) {
1079            if (category.equals(portlet.getControlPanelEntryCategory())) {
1080                portletsSet.add(portlet);
1081            }
1082        }
1083
1084        return filterControlPanelPortlets(portletsSet, category, themeDisplay);
1085    }
1086
1087    public String getCurrentCompleteURL(HttpServletRequest request) {
1088        String currentCompleteURL = (String)request.getAttribute(
1089            WebKeys.CURRENT_COMPLETE_URL);
1090
1091        if (currentCompleteURL == null) {
1092            currentCompleteURL = HttpUtil.getCompleteURL(request);
1093
1094            request.setAttribute(
1095                WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1096        }
1097
1098        return currentCompleteURL;
1099    }
1100
1101    public String getCurrentURL(HttpServletRequest request) {
1102        String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1103
1104        if (currentURL == null) {
1105            currentURL = ParamUtil.getString(request, "currentURL");
1106
1107            if (Validator.isNull(currentURL)) {
1108                currentURL = HttpUtil.getCompleteURL(request);
1109
1110                if ((Validator.isNotNull(currentURL)) &&
1111                    (currentURL.indexOf(_J_SECURITY_CHECK) == -1)) {
1112
1113                    currentURL = currentURL.substring(
1114                        currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1115                            Http.PROTOCOL_DELIMITER.length());
1116
1117                    currentURL = currentURL.substring(
1118                        currentURL.indexOf(StringPool.SLASH));
1119                }
1120
1121                if (Validator.isNotNull(currentURL) &&
1122                    FacebookUtil.isFacebook(currentURL)) {
1123
1124                    String[] facebookData = FacebookUtil.getFacebookData(
1125                        request);
1126
1127                    currentURL =
1128                        FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1129                            facebookData[2];
1130                }
1131            }
1132
1133            if (Validator.isNull(currentURL)) {
1134                currentURL = getPathMain();
1135            }
1136
1137            request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1138        }
1139
1140        return currentURL;
1141    }
1142
1143    public String getCurrentURL(PortletRequest portletRequest) {
1144        return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1145    }
1146
1147    public String getCustomSQLFunctionIsNotNull() {
1148        return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1149    }
1150
1151    public String getCustomSQLFunctionIsNull() {
1152        return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1153    }
1154
1155    public Date getDate(int month, int day, int year) {
1156        try {
1157            return getDate(month, day, year, null);
1158        }
1159        catch (PortalException pe) {
1160            throw new RuntimeException();
1161        }
1162    }
1163
1164    public Date getDate(
1165            int month, int day, int year, int hour, int min, PortalException pe)
1166        throws PortalException {
1167
1168        return getDate(month, day, year, hour, min, null, pe);
1169    }
1170
1171    public Date getDate(
1172            int month, int day, int year, int hour, int min, TimeZone timeZone,
1173            PortalException pe)
1174        throws PortalException {
1175
1176        if (!Validator.isGregorianDate(month, day, year)) {
1177            if (pe != null) {
1178                throw pe;
1179            }
1180            else {
1181                return null;
1182            }
1183        }
1184        else {
1185            Calendar cal = null;
1186
1187            if (timeZone == null) {
1188                cal = CalendarFactoryUtil.getCalendar();
1189            }
1190            else {
1191                cal = CalendarFactoryUtil.getCalendar(timeZone);
1192            }
1193
1194            if ((hour == -1) || (min == -1)) {
1195                cal.set(year, month, day, 0, 0, 0);
1196            }
1197            else {
1198                cal.set(year, month, day, hour, min, 0);
1199            }
1200
1201            cal.set(Calendar.MILLISECOND, 0);
1202
1203            Date date = cal.getTime();
1204
1205            /*if (timeZone != null &&
1206                cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
1207
1208                throw pe;
1209            }*/
1210
1211            return date;
1212        }
1213    }
1214
1215    public Date getDate(int month, int day, int year, PortalException pe)
1216        throws PortalException {
1217
1218        return getDate(month, day, year, null, pe);
1219    }
1220
1221    public Date getDate(
1222            int month, int day, int year, TimeZone timeZone, PortalException pe)
1223        throws PortalException {
1224
1225        return getDate(month, day, year, -1, -1, timeZone, pe);
1226    }
1227
1228    public long getDefaultCompanyId() {
1229        return PortalInstances.getDefaultCompanyId();
1230    }
1231
1232    public Map<String, Serializable> getExpandoBridgeAttributes(
1233            ExpandoBridge expandoBridge, PortletRequest portletRequest)
1234        throws PortalException, SystemException {
1235
1236        Map<String, Serializable> attributes =
1237            new HashMap<String, Serializable>();
1238
1239        List<String> names = new ArrayList<String>();
1240
1241        Enumeration<String> enu = portletRequest.getParameterNames();
1242
1243        while (enu.hasMoreElements()) {
1244            String param = enu.nextElement();
1245
1246            if (param.indexOf("ExpandoAttributeName--") != -1) {
1247                String name = ParamUtil.getString(portletRequest, param);
1248
1249                names.add(name);
1250            }
1251        }
1252
1253        for (String name : names) {
1254            int type = expandoBridge.getAttributeType(name);
1255
1256            Serializable value = EditExpandoAction.getValue(
1257                portletRequest, "ExpandoAttribute--" + name + "--", type);
1258
1259            attributes.put(name, value);
1260        }
1261
1262        return attributes;
1263    }
1264
1265    public String getFirstPageLayoutTypes(PageContext pageContext) {
1266        StringBundler sb = new StringBundler();
1267
1268        for (String type : PropsValues.LAYOUT_TYPES) {
1269            if (isLayoutFirstPageable(type)) {
1270                sb.append(
1271                    LanguageUtil.get(pageContext, "layout.types." + type));
1272                sb.append(StringPool.COMMA);
1273                sb.append(StringPool.SPACE);
1274            }
1275        }
1276
1277        if (sb.index() >= 2) {
1278            sb.setIndex(sb.index() - 2);
1279        }
1280
1281        return sb.toString();
1282    }
1283
1284    public String getGlobalLibDir() {
1285        return _globalLibDir;
1286    }
1287
1288    public String getGoogleGadgetURL(
1289            Portlet portlet, ThemeDisplay themeDisplay)
1290        throws PortalException, SystemException {
1291
1292        return _getServletURL(
1293            portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
1294    }
1295
1296    public String[] getGuestPermissions(HttpServletRequest request) {
1297        return request.getParameterValues("guestPermissions");
1298    }
1299
1300    public String[] getGuestPermissions(PortletRequest portletRequest) {
1301        return portletRequest.getParameterValues("guestPermissions");
1302    }
1303
1304    public String getHomeURL(HttpServletRequest request)
1305        throws PortalException, SystemException {
1306
1307        String portalURL = getPortalURL(request);
1308
1309        Company company = getCompany(request);
1310
1311        String homeURL = company.getHomeURL();
1312
1313        if (Validator.isNull(homeURL)) {
1314            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
1315        }
1316
1317        return portalURL + _pathContext + homeURL;
1318    }
1319
1320    public String getHost(HttpServletRequest request) {
1321        request = getOriginalServletRequest(request);
1322
1323        String host = request.getHeader("Host");
1324
1325        if (host != null) {
1326            host = host.trim().toLowerCase();
1327
1328            int pos = host.indexOf(':');
1329
1330            if (pos >= 0) {
1331                host = host.substring(0, pos);
1332            }
1333        }
1334        else {
1335            host = null;
1336        }
1337
1338        return host;
1339    }
1340
1341    public String getHost(PortletRequest portletRequest) {
1342        return getHost(getHttpServletRequest(portletRequest));
1343    }
1344
1345    public HttpServletRequest getHttpServletRequest(
1346        PortletRequest portletRequest) {
1347
1348        PortletRequestImpl portletRequestImpl =
1349            PortletRequestImpl.getPortletRequestImpl(portletRequest);
1350
1351        return portletRequestImpl.getHttpServletRequest();
1352    }
1353
1354    public HttpServletResponse getHttpServletResponse(
1355        PortletResponse portletResponse) {
1356
1357        PortletResponseImpl portletResponseImpl =
1358            PortletResponseImpl.getPortletResponseImpl(portletResponse);
1359
1360        return portletResponseImpl.getHttpServletResponse();
1361    }
1362
1363    public String getJsSafePortletId(String portletId) {
1364        return JS.getSafeName(portletId);
1365    }
1366
1367    public String getLayoutActualURL(Layout layout) {
1368        return getLayoutActualURL(layout, getPathMain());
1369    }
1370
1371    public String getLayoutActualURL(Layout layout, String mainPath) {
1372        Map<String, String> variables = new HashMap<String, String>();
1373
1374        variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
1375        variables.put("liferay:mainPath", mainPath);
1376        variables.put("liferay:plid", String.valueOf(layout.getPlid()));
1377
1378        UnicodeProperties typeSettingsProperties =
1379            layout.getLayoutType().getTypeSettingsProperties();
1380
1381        Iterator<Map.Entry<String, String>> itr =
1382            typeSettingsProperties.entrySet().iterator();
1383
1384        while (itr.hasNext()) {
1385            Map.Entry<String, String> entry = itr.next();
1386
1387            String key = entry.getKey();
1388            String value = entry.getValue();
1389
1390            variables.put(key, value);
1391        }
1392
1393        LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
1394
1395        return layoutSettings.getURL(variables);
1396    }
1397
1398    public String getLayoutActualURL(
1399            long groupId, boolean privateLayout, String mainPath,
1400            String friendlyURL)
1401        throws PortalException, SystemException {
1402
1403        return getLayoutActualURL(
1404            groupId, privateLayout, mainPath, friendlyURL, null, null);
1405    }
1406
1407    public String getLayoutActualURL(
1408            long groupId, boolean privateLayout, String mainPath,
1409            String friendlyURL, Map<String, String[]> params,
1410            Map<String, Object> requestContext)
1411        throws PortalException, SystemException {
1412
1413        Layout layout = null;
1414        String queryString = StringPool.BLANK;
1415
1416        if (Validator.isNull(friendlyURL)) {
1417            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
1418                groupId, privateLayout,
1419                LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
1420
1421            if (layouts.size() > 0) {
1422                layout = layouts.get(0);
1423            }
1424            else {
1425                throw new NoSuchLayoutException(
1426                    "{groupId=" + groupId + ",privateLayout=" + privateLayout +
1427                        "} does not have any layouts");
1428            }
1429        }
1430        else {
1431            Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
1432                groupId, privateLayout, friendlyURL, params, requestContext);
1433
1434            layout = (Layout)friendlyURLMapper[0];
1435            queryString = (String)friendlyURLMapper[1];
1436        }
1437
1438        String layoutActualURL = getLayoutActualURL(layout, mainPath);
1439
1440        if (Validator.isNotNull(queryString)) {
1441            layoutActualURL = layoutActualURL + queryString;
1442        }
1443        else if (params.isEmpty()) {
1444            UnicodeProperties typeSettingsProperties =
1445                layout.getLayoutType().getTypeSettingsProperties();
1446
1447            queryString = typeSettingsProperties.getProperty("query-string");
1448
1449            if (Validator.isNotNull(queryString) &&
1450                layoutActualURL.contains(StringPool.QUESTION)) {
1451
1452                layoutActualURL =
1453                    layoutActualURL + StringPool.AMPERSAND + queryString;
1454            }
1455        }
1456
1457        return layoutActualURL;
1458    }
1459
1460    public String getLayoutEditPage(Layout layout) {
1461        LayoutSettings layoutSettings = LayoutSettings.getInstance(
1462            layout.getType());
1463
1464        return layoutSettings.getEditPage();
1465    }
1466
1467    public String getLayoutEditPage(String type) {
1468        LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
1469
1470        return layoutSettings.getEditPage();
1471    }
1472
1473    public String getLayoutFriendlyURL(
1474            Layout layout, ThemeDisplay themeDisplay)
1475        throws PortalException, SystemException {
1476
1477        if (!isLayoutFriendliable(layout)) {
1478            return null;
1479        }
1480
1481        String layoutFriendlyURL = layout.getFriendlyURL();
1482
1483        LayoutSet layoutSet = layout.getLayoutSet();
1484
1485        long curLayoutSetId =
1486            themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1487
1488        String portalURL = StringPool.BLANK;
1489
1490        if (!themeDisplay.getServerName().equals(_LOCALHOST)) {
1491            String virtualHost = layoutSet.getVirtualHost();
1492
1493            if (Validator.isNull(virtualHost) &&
1494                Validator.isNotNull(
1495                    PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME) &&
1496                !layoutSet.isPrivateLayout()) {
1497
1498                try {
1499                    Group group = GroupLocalServiceUtil.getGroup(
1500                        themeDisplay.getCompanyId(),
1501                        PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME);
1502
1503                    if (layoutSet.getGroupId() == group.getGroupId()) {
1504                        Company company = themeDisplay.getCompany();
1505
1506                        virtualHost = company.getVirtualHost();
1507                    }
1508                }
1509                catch (Exception e) {
1510                    _log.error(e, e);
1511                }
1512            }
1513
1514            if (Validator.isNotNull(virtualHost)) {
1515                virtualHost = getPortalURL(
1516                    virtualHost, themeDisplay.getServerPort(),
1517                    themeDisplay.isSecure());
1518
1519                String portalDomain = HttpUtil.getDomain(
1520                    themeDisplay.getPortalURL());
1521
1522                if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1523                    (virtualHost.indexOf(portalDomain) != -1)) {
1524
1525                    if (themeDisplay.isWidget()) {
1526                        layoutFriendlyURL =
1527                            PropsValues.WIDGET_SERVLET_MAPPING +
1528                                layoutFriendlyURL;
1529                    }
1530
1531                    if (themeDisplay.isI18n()) {
1532                        layoutFriendlyURL =
1533                            themeDisplay.getI18nPath() + layoutFriendlyURL;
1534                    }
1535
1536                    return virtualHost + _pathContext + layoutFriendlyURL;
1537                }
1538            }
1539            else {
1540                if ((layoutSet.getLayoutSetId() != curLayoutSetId) &&
1541                    (layout.getGroup().getClassPK() !=
1542                        themeDisplay.getUserId())) {
1543
1544                    virtualHost = themeDisplay.getCompany().getVirtualHost();
1545
1546                    if (!virtualHost.equalsIgnoreCase(_LOCALHOST)) {
1547                        portalURL = getPortalURL(
1548                            virtualHost, themeDisplay.getServerPort(),
1549                            themeDisplay.isSecure());
1550                    }
1551                }
1552            }
1553        }
1554
1555        Group group = layout.getGroup();
1556
1557        String friendlyURL = null;
1558
1559        if (layout.isPrivateLayout()) {
1560            if (group.isUser()) {
1561                friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1562            }
1563            else {
1564                friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1565            }
1566        }
1567        else {
1568            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1569        }
1570
1571        if (themeDisplay.isWidget()) {
1572            friendlyURL = PropsValues.WIDGET_SERVLET_MAPPING + friendlyURL;
1573        }
1574
1575        if (themeDisplay.isI18n()) {
1576            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
1577        }
1578
1579        return portalURL + _pathContext + friendlyURL + group.getFriendlyURL() +
1580            layoutFriendlyURL;
1581    }
1582
1583    public String getLayoutFriendlyURL(
1584            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1585        throws PortalException, SystemException {
1586
1587        String i18nLanguageId = themeDisplay.getI18nLanguageId();
1588        String i18nPath = themeDisplay.getI18nPath();
1589
1590        try {
1591            String tempI18nLanguageId = null;
1592
1593            if ((I18nFilter.getLanguageIds().contains(locale.toString())) &&
1594                ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
1595                 (!locale.equals(LocaleUtil.getDefault()))) ||
1596                (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
1597
1598                tempI18nLanguageId = locale.toString();
1599            }
1600
1601            String tempI18nPath = null;
1602
1603            if (Validator.isNotNull(tempI18nLanguageId)) {
1604                tempI18nPath = StringPool.SLASH + tempI18nLanguageId;
1605
1606                if (!LanguageUtil.isDuplicateLanguageCode(
1607                        locale.getLanguage())) {
1608
1609                    tempI18nPath = StringPool.SLASH + locale.getLanguage();
1610                }
1611                else {
1612                    Locale priorityLocale = LanguageUtil.getLocale(
1613                        locale.getLanguage());
1614
1615                    if (locale.equals(priorityLocale)) {
1616                        tempI18nPath = StringPool.SLASH + locale.getLanguage();
1617                    }
1618                }
1619            }
1620
1621            themeDisplay.setI18nLanguageId(tempI18nLanguageId);
1622            themeDisplay.setI18nPath(tempI18nPath);
1623
1624            return getLayoutFriendlyURL(layout, themeDisplay);
1625        }
1626        finally {
1627            themeDisplay.setI18nLanguageId(i18nLanguageId);
1628            themeDisplay.setI18nPath(i18nPath);
1629        }
1630    }
1631
1632    public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
1633        throws PortalException, SystemException {
1634
1635        return getLayoutFullURL(layout, themeDisplay, true);
1636    }
1637
1638    public String getLayoutFullURL(
1639            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1640        throws PortalException, SystemException {
1641
1642        String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
1643        String portalURL = themeDisplay.getPortalURL();
1644
1645        if (StringUtil.startsWith(layoutURL, portalURL)) {
1646            return layoutURL;
1647        }
1648        else {
1649            return portalURL + layoutURL;
1650        }
1651    }
1652
1653    public String getLayoutFullURL(long groupId, String portletId)
1654        throws PortalException, SystemException {
1655
1656        long plid = getPlidFromPortletId(groupId, portletId);
1657
1658        if (plid == LayoutConstants.DEFAULT_PLID) {
1659            return null;
1660        }
1661
1662        StringBundler sb = new StringBundler(4);
1663
1664        Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1665
1666        Company company = CompanyLocalServiceUtil.getCompany(
1667            layout.getCompanyId());
1668
1669        Group group = GroupLocalServiceUtil.getGroup(groupId);
1670
1671        String portalURL = getPortalURL(
1672            company.getVirtualHost(), getPortalPort(), false);
1673
1674        sb.append(portalURL);
1675
1676        if (layout.isPrivateLayout()) {
1677            if (group.isUser()) {
1678                sb.append(PortalUtil.getPathFriendlyURLPrivateUser());
1679            }
1680            else {
1681                sb.append(PortalUtil.getPathFriendlyURLPrivateGroup());
1682            }
1683        }
1684        else {
1685            sb.append(PortalUtil.getPathFriendlyURLPublic());
1686        }
1687
1688        sb.append(group.getFriendlyURL());
1689        sb.append(layout.getFriendlyURL());
1690
1691        return sb.toString();
1692    }
1693
1694    public String getLayoutFullURL(ThemeDisplay themeDisplay)
1695        throws PortalException, SystemException {
1696
1697        return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
1698    }
1699
1700    public String getLayoutSetFriendlyURL(
1701            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1702        throws PortalException, SystemException {
1703
1704        String virtualHost = layoutSet.getVirtualHost();
1705
1706        if (Validator.isNull(virtualHost) &&
1707            Validator.isNotNull(
1708                PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME) &&
1709            !layoutSet.isPrivateLayout()) {
1710
1711            try {
1712                Group group = GroupLocalServiceUtil.getGroup(
1713                    themeDisplay.getCompanyId(),
1714                    PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME);
1715
1716                if (layoutSet.getGroupId() == group.getGroupId()) {
1717                    Company company = themeDisplay.getCompany();
1718
1719                    virtualHost = company.getVirtualHost();
1720                }
1721            }
1722            catch (Exception e) {
1723                _log.error(e, e);
1724            }
1725        }
1726
1727        if (Validator.isNotNull(virtualHost)) {
1728            String portalURL = getPortalURL(
1729                virtualHost, themeDisplay.getServerPort(),
1730                themeDisplay.isSecure());
1731
1732            // Use the layout set's virtual host setting only if the layout set
1733            // is already used for the current request
1734
1735            long curLayoutSetId =
1736                themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1737
1738            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1739                (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1740
1741                String layoutSetFriendlyURL = StringPool.BLANK;
1742
1743                if (themeDisplay.isI18n()) {
1744                    layoutSetFriendlyURL = themeDisplay.getI18nPath();
1745                }
1746
1747                return portalURL + _pathContext + layoutSetFriendlyURL;
1748            }
1749        }
1750
1751        Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1752
1753        String friendlyURL = null;
1754
1755        if (layoutSet.isPrivateLayout()) {
1756            if (group.isUser()) {
1757                friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1758            }
1759            else {
1760                friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1761            }
1762        }
1763        else {
1764            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1765        }
1766
1767        if (themeDisplay.isI18n()) {
1768            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
1769        }
1770
1771        return _pathContext + friendlyURL + group.getFriendlyURL();
1772    }
1773
1774    public String getLayoutTarget(Layout layout) {
1775        UnicodeProperties typeSettingsProps =
1776            layout.getTypeSettingsProperties();
1777
1778        String target = typeSettingsProps.getProperty("target");
1779
1780        if (Validator.isNull(target)) {
1781            target = StringPool.BLANK;
1782        }
1783        else {
1784            target = "target=\"" + target + "\"";
1785        }
1786
1787        return target;
1788    }
1789
1790    public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
1791        throws PortalException, SystemException {
1792
1793        return getLayoutURL(layout, themeDisplay, true);
1794    }
1795
1796    public String getLayoutURL(
1797            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1798        throws PortalException, SystemException {
1799
1800        if (layout == null) {
1801            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
1802        }
1803
1804        if (!layout.isTypeURL()) {
1805            String layoutFriendlyURL = getLayoutFriendlyURL(
1806                layout, themeDisplay);
1807
1808            if (Validator.isNotNull(layoutFriendlyURL)) {
1809                if (doAsUser) {
1810                    if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
1811                        layoutFriendlyURL = HttpUtil.addParameter(
1812                            layoutFriendlyURL, "doAsUserId",
1813                            themeDisplay.getDoAsUserId());
1814                    }
1815
1816                    if (Validator.isNotNull(
1817                            themeDisplay.getDoAsUserLanguageId())) {
1818
1819                        layoutFriendlyURL = HttpUtil.addParameter(
1820                            layoutFriendlyURL, "doAsUserLanguageId",
1821                            themeDisplay.getDoAsUserLanguageId());
1822                    }
1823                }
1824
1825                if (layout.isTypeControlPanel()) {
1826                    if (themeDisplay.getRefererPlid() !=
1827                            LayoutConstants.DEFAULT_PLID) {
1828
1829                        layoutFriendlyURL = HttpUtil.addParameter(
1830                            layoutFriendlyURL, "refererPlid",
1831                            themeDisplay.getRefererPlid());
1832                    }
1833
1834                    if (themeDisplay.getDoAsGroupId() > 0) {
1835                        layoutFriendlyURL = HttpUtil.addParameter(
1836                            layoutFriendlyURL, "doAsGroupId",
1837                            themeDisplay.getDoAsGroupId());
1838                    }
1839                }
1840
1841                return layoutFriendlyURL;
1842            }
1843        }
1844
1845        String layoutURL = getLayoutActualURL(layout);
1846
1847        if (doAsUser) {
1848            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
1849                layoutURL = HttpUtil.addParameter(
1850                    layoutURL, "doAsUserId", themeDisplay.getDoAsUserId());
1851            }
1852
1853            if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
1854                layoutURL = HttpUtil.addParameter(
1855                    layoutURL, "doAsUserLanguageId",
1856                    themeDisplay.getDoAsUserLanguageId());
1857            }
1858        }
1859
1860        if (layout.isTypeControlPanel()) {
1861            if (themeDisplay.getDoAsGroupId() > 0) {
1862                layoutURL = HttpUtil.addParameter(
1863                    layoutURL, "doAsGroupId", themeDisplay.getDoAsGroupId());
1864            }
1865
1866            if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
1867                layoutURL = HttpUtil.addParameter(
1868                    layoutURL, "refererPlid", themeDisplay.getRefererPlid());
1869            }
1870        }
1871
1872        return layoutURL;
1873    }
1874
1875    public String getLayoutURL(ThemeDisplay themeDisplay)
1876        throws PortalException, SystemException {
1877
1878        return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
1879    }
1880
1881    public String getLayoutViewPage(Layout layout) {
1882        LayoutSettings layoutSettings = LayoutSettings.getInstance(
1883            layout.getType());
1884
1885        return layoutSettings.getViewPage();
1886    }
1887
1888    public String getLayoutViewPage(String type) {
1889        LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
1890
1891        return layoutSettings.getViewPage();
1892    }
1893
1894    public LiferayPortletResponse getLiferayPortletResponse(
1895        PortletResponse portletResponse) {
1896
1897        PortletResponseImpl portletResponseImpl =
1898            PortletResponseImpl.getPortletResponseImpl(portletResponse);
1899
1900        return portletResponseImpl;
1901    }
1902
1903    public Locale getLocale(HttpServletRequest request) {
1904        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1905            WebKeys.THEME_DISPLAY);
1906
1907        if (themeDisplay != null) {
1908            return themeDisplay.getLocale();
1909        }
1910        else {
1911            HttpSession session = request.getSession();
1912
1913            return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1914        }
1915    }
1916
1917    public Locale getLocale(RenderRequest renderRequest) {
1918        return getLocale(getHttpServletRequest(renderRequest));
1919    }
1920
1921    public String getNetvibesURL(
1922            Portlet portlet, ThemeDisplay themeDisplay)
1923        throws PortalException, SystemException {
1924
1925        return _getServletURL(
1926            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
1927    }
1928
1929    public HttpServletRequest getOriginalServletRequest(
1930        HttpServletRequest request) {
1931
1932        HttpServletRequest originalRequest = request;
1933
1934        while (originalRequest.getClass().getName().startsWith(
1935                    "com.liferay.")) {
1936
1937            // Get original request so that portlets inside portlets render
1938            // properly
1939
1940            originalRequest = (HttpServletRequest)
1941                ((HttpServletRequestWrapper)originalRequest).getRequest();
1942        }
1943
1944        return originalRequest;
1945    }
1946
1947    public long getParentGroupId(long groupId)
1948        throws PortalException, SystemException {
1949
1950        if (groupId <= 0) {
1951            return 0;
1952        }
1953
1954        Group group = GroupLocalServiceUtil.getGroup(groupId);
1955
1956        long parentGroupId = groupId;
1957
1958        if (group.isLayout()) {
1959            parentGroupId = group.getParentGroupId();
1960        }
1961
1962        return parentGroupId;
1963    }
1964
1965    public String getPathContext() {
1966        return _pathContext;
1967    }
1968
1969    public String getPathFriendlyURLPrivateGroup() {
1970        return _pathFriendlyURLPrivateGroup;
1971    }
1972
1973    public String getPathFriendlyURLPrivateUser() {
1974        return _pathFriendlyURLPrivateUser;
1975    }
1976
1977    public String getPathFriendlyURLPublic() {
1978        return _pathFriendlyURLPublic;
1979    }
1980
1981    public String getPathImage() {
1982        return _pathImage;
1983    }
1984
1985    public String getPathMain() {
1986        return _pathMain;
1987    }
1988
1989    public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1990        if (Validator.isNull(friendlyURL)) {
1991            return LayoutConstants.DEFAULT_PLID;
1992        }
1993
1994        String[] urlParts = friendlyURL.split("\\/", 4);
1995
1996        if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1997            (urlParts.length != 4)) {
1998
1999            return LayoutConstants.DEFAULT_PLID;
2000        }
2001
2002        boolean privateLayout = true;
2003
2004        String urlPrefix = StringPool.SLASH + urlParts[1];
2005
2006        if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
2007            privateLayout = false;
2008        }
2009        else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
2010                 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
2011
2012            privateLayout = true;
2013        }
2014        else {
2015            return LayoutConstants.DEFAULT_PLID;
2016        }
2017
2018        Group group = null;
2019
2020        try {
2021            group = GroupLocalServiceUtil.getFriendlyURLGroup(
2022                companyId, StringPool.SLASH + urlParts[2]);
2023        }
2024        catch (Exception e) {
2025        }
2026
2027        if (group != null) {
2028            Layout layout = null;
2029
2030            try {
2031                String layoutFriendlyURL = null;
2032
2033                if (urlParts.length == 4) {
2034                    layoutFriendlyURL = StringPool.SLASH + urlParts[3];
2035                }
2036                else {
2037                    layoutFriendlyURL = "/1";
2038                }
2039
2040                layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2041                    group.getGroupId(), privateLayout, layoutFriendlyURL);
2042
2043                return layout.getPlid();
2044            }
2045            catch (Exception e) {
2046            }
2047        }
2048
2049        return LayoutConstants.DEFAULT_PLID;
2050    }
2051
2052    public long getPlidFromPortletId(
2053            long groupId, boolean privateLayout, String portletId)
2054        throws PortalException, SystemException {
2055
2056        long plid = LayoutConstants.DEFAULT_PLID;
2057
2058        StringBundler sb = new StringBundler(5);
2059
2060        sb.append(groupId);
2061        sb.append(StringPool.SPACE);
2062        sb.append(privateLayout);
2063        sb.append(StringPool.SPACE);
2064        sb.append(portletId);
2065
2066        String key = sb.toString();
2067
2068        Long plidObj = _plidToPortletIdCache.get(key);
2069
2070        if (plidObj == null) {
2071            plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
2072
2073            if (plid != LayoutConstants.DEFAULT_PLID) {
2074                _plidToPortletIdCache.put(key, plid);
2075            }
2076        }
2077        else {
2078            plid = plidObj.longValue();
2079
2080            boolean validPlid = false;
2081
2082            try {
2083                Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2084
2085                LayoutTypePortlet layoutTypePortlet =
2086                    (LayoutTypePortlet)layout.getLayoutType();
2087
2088                if (layoutTypePortlet.hasDefaultScopePortletId(
2089                        groupId, portletId)) {
2090
2091                    validPlid = true;
2092                }
2093            }
2094            catch (Exception e) {
2095            }
2096
2097            if (!validPlid) {
2098                _plidToPortletIdCache.remove(key);
2099
2100                plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
2101
2102                if (plid != LayoutConstants.DEFAULT_PLID) {
2103                    _plidToPortletIdCache.put(key, plid);
2104                }
2105            }
2106        }
2107
2108        return plid;
2109    }
2110
2111    public long getPlidFromPortletId(long groupId, String portletId)
2112        throws PortalException, SystemException {
2113
2114        long plid = getPlidFromPortletId(groupId, false, portletId);
2115
2116        if (plid == LayoutConstants.DEFAULT_PLID) {
2117            plid = getPlidFromPortletId(groupId, true, portletId);
2118        }
2119
2120        if (plid == LayoutConstants.DEFAULT_PLID) {
2121            if (_log.isDebugEnabled()) {
2122                _log.debug(
2123                    "Portlet " + portletId +
2124                        " does not exist on a page in group " + groupId);
2125            }
2126        }
2127
2128        return plid;
2129    }
2130
2131    public String getPortalLibDir() {
2132        return _portalLibDir;
2133    }
2134
2135    public int getPortalPort() {
2136        return _portalPort;
2137    }
2138
2139    public Properties getPortalProperties() {
2140        return PropsUtil.getProperties();
2141    }
2142
2143    public String getPortalURL(HttpServletRequest request) {
2144        return getPortalURL(request, request.isSecure());
2145    }
2146
2147    public String getPortalURL(HttpServletRequest request, boolean secure) {
2148        return getPortalURL(
2149            request.getServerName(), request.getServerPort(), secure);
2150    }
2151
2152    public String getPortalURL(PortletRequest portletRequest) {
2153        return getPortalURL(portletRequest, portletRequest.isSecure());
2154    }
2155
2156    public String getPortalURL(PortletRequest portletRequest, boolean secure) {
2157        return getPortalURL(
2158            portletRequest.getServerName(), portletRequest.getServerPort(),
2159            secure);
2160    }
2161
2162    public String getPortalURL(
2163        String serverName, int serverPort, boolean secure) {
2164
2165        StringBundler sb = new StringBundler();
2166
2167        if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
2168            sb.append(Http.HTTPS_WITH_SLASH);
2169        }
2170        else {
2171            sb.append(Http.HTTP_WITH_SLASH);
2172        }
2173
2174        if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
2175            sb.append(serverName);
2176        }
2177        else {
2178            sb.append(PropsValues.WEB_SERVER_HOST);
2179        }
2180
2181        if (!secure) {
2182            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
2183                if ((serverPort != Http.HTTP_PORT) &&
2184                    (serverPort != Http.HTTPS_PORT)) {
2185
2186                    sb.append(StringPool.COLON);
2187                    sb.append(serverPort);
2188                }
2189            }
2190            else {
2191                if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
2192                    sb.append(StringPool.COLON);
2193                    sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
2194                }
2195            }
2196        }
2197
2198        if (secure) {
2199            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
2200                if ((serverPort != Http.HTTP_PORT) &&
2201                    (serverPort != Http.HTTPS_PORT)) {
2202
2203                    sb.append(StringPool.COLON);
2204                    sb.append(serverPort);
2205                }
2206            }
2207            else {
2208                if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
2209                    sb.append(StringPool.COLON);
2210                    sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
2211                }
2212            }
2213        }
2214
2215        return sb.toString();
2216    }
2217
2218    public String getPortalURL(ThemeDisplay themeDisplay)
2219        throws PortalException, SystemException {
2220
2221        String serverName = themeDisplay.getServerName();
2222
2223        Layout layout = themeDisplay.getLayout();
2224
2225        if (layout != null) {
2226            LayoutSet layoutSet = layout.getLayoutSet();
2227
2228            String virtualHost = layoutSet.getVirtualHost();
2229
2230            if (Validator.isNotNull(virtualHost)) {
2231                serverName = virtualHost;
2232            }
2233        }
2234
2235        return getPortalURL(
2236            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
2237    }
2238
2239    public String getPortalWebDir() {
2240        return _portalWebDir;
2241    }
2242
2243    public List<KeyValuePair> getPortletBreadcrumbList(
2244        HttpServletRequest request) {
2245
2246        return (List<KeyValuePair>)request.getAttribute(
2247            WebKeys.PORTLET_BREADCRUMB_MAP);
2248    }
2249
2250    public String getPortletDescription(
2251        Portlet portlet, ServletContext servletContext, Locale locale) {
2252
2253        PortletConfig portletConfig = PortletConfigFactory.create(
2254            portlet, servletContext);
2255
2256        ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
2257
2258        return resourceBundle.getString(
2259            JavaConstants.JAVAX_PORTLET_DESCRIPTION);
2260    }
2261
2262    public String getPortletDescription(Portlet portlet, User user) {
2263        return getPortletDescription(portlet.getPortletId(), user);
2264    }
2265
2266    public String getPortletDescription(String portletId, Locale locale) {
2267        return LanguageUtil.get(
2268            locale,
2269            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2270                StringPool.PERIOD).concat(portletId));
2271    }
2272
2273    public String getPortletDescription(String portletId, String languageId) {
2274        Locale locale = LocaleUtil.fromLanguageId(languageId);
2275
2276        return getPortletDescription(portletId, locale);
2277    }
2278
2279    public String getPortletDescription(String portletId, User user) {
2280        return LanguageUtil.get(
2281            user.getLocale(),
2282            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2283                StringPool.PERIOD).concat(portletId));
2284    }
2285
2286    public Object[] getPortletFriendlyURLMapper(
2287            long groupId, boolean privateLayout, String url,
2288            Map<String, String[]> params, Map<String, Object> requestContext)
2289        throws PortalException, SystemException {
2290
2291        boolean foundFriendlyURLMapper = false;
2292
2293        String friendlyURL = url;
2294        String queryString = StringPool.BLANK;
2295
2296        List<Portlet> portlets =
2297            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
2298
2299        Iterator<Portlet> itr = portlets.iterator();
2300
2301        while (itr.hasNext()) {
2302            Portlet portlet = itr.next();
2303
2304            FriendlyURLMapper friendlyURLMapper =
2305                portlet.getFriendlyURLMapperInstance();
2306
2307            if (url.endsWith(
2308                    StringPool.SLASH + friendlyURLMapper.getMapping())) {
2309
2310                url += StringPool.SLASH;
2311            }
2312
2313            int pos = -1;
2314
2315            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2316                pos = url.indexOf(
2317                    FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
2318                        StringPool.SLASH);
2319            }
2320            else {
2321                pos = url.indexOf(
2322                    StringPool.SLASH + friendlyURLMapper.getMapping() +
2323                        StringPool.SLASH);
2324            }
2325
2326            if (pos != -1) {
2327                foundFriendlyURLMapper = true;
2328
2329                friendlyURL = url.substring(0, pos);
2330
2331                Map<String, String[]> actualParams =
2332                    new HashMap<String, String[]>();
2333
2334                /*Object lifecycle = actualParams.get("p_p_lifecycle");
2335
2336                if ((lifecycle == null) ||
2337                    (((String[])lifecycle).length == 0)) {
2338
2339                    actualParams.put("p_p_lifecycle", "0");
2340                }
2341
2342                Object state = actualParams.get("p_p_state");
2343
2344                if ((state == null) || (((String[])state).length == 0)) {
2345                    actualParams.put(
2346                        "p_p_state", WindowState.MAXIMIZED.toString());
2347                }*/
2348
2349                Map<String, String> prpIdentifiers =
2350                    new HashMap<String, String>();
2351
2352                Set<PublicRenderParameter> publicRenderParameters =
2353                    portlet.getPublicRenderParameters();
2354
2355                for (PublicRenderParameter publicRenderParameter :
2356                        publicRenderParameters) {
2357
2358                    QName qName = publicRenderParameter.getQName();
2359
2360                    String publicRenderParameterIdentifier =
2361                        qName.getLocalPart();
2362                    String publicRenderParameterName =
2363                        PortletQNameUtil.getPublicRenderParameterName(qName);
2364
2365                    prpIdentifiers.put(
2366                        publicRenderParameterIdentifier,
2367                        publicRenderParameterName);
2368                }
2369
2370                FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
2371
2372                if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2373                    friendlyURLMapper.populateParams(
2374                        url.substring(pos + 2), actualParams, requestContext);
2375                }
2376                else {
2377                    friendlyURLMapper.populateParams(
2378                        url.substring(pos), actualParams, requestContext);
2379                }
2380
2381                queryString =
2382                    StringPool.AMPERSAND +
2383                        HttpUtil.parameterMapToString(actualParams, false);
2384
2385                break;
2386            }
2387        }
2388
2389        if (!foundFriendlyURLMapper) {
2390            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
2391
2392            if (x != -1) {
2393                int y = url.indexOf(StringPool.SLASH, x + 3);
2394
2395                if (y == -1) {
2396                    y = url.length();
2397                }
2398
2399                String ppid = url.substring(x + 3, y);
2400
2401                if (Validator.isNotNull(ppid)) {
2402                    friendlyURL = url.substring(0, x);
2403
2404                    Map<String, String[]> actualParams = null;
2405
2406                    if (params != null) {
2407                        actualParams = new HashMap<String, String[]>(params);
2408                    }
2409                    else {
2410                        actualParams = new HashMap<String, String[]>();
2411                    }
2412
2413                    actualParams.put("p_p_id", new String[] {ppid});
2414                    actualParams.put("p_p_lifecycle", new String[] {"0"});
2415                    actualParams.put(
2416                        "p_p_state",
2417                        new String[] {WindowState.MAXIMIZED.toString()});
2418                    actualParams.put(
2419                        "p_p_mode", new String[] {PortletMode.VIEW.toString()});
2420
2421                    queryString =
2422                        StringPool.AMPERSAND +
2423                            HttpUtil.parameterMapToString(actualParams, false);
2424                }
2425            }
2426        }
2427
2428        friendlyURL = StringUtil.replace(
2429            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
2430
2431        if (friendlyURL.endsWith(StringPool.SLASH)) {
2432            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
2433        }
2434
2435        Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2436            groupId, privateLayout, friendlyURL);
2437
2438        return new Object[] {layout, queryString};
2439    }
2440
2441    public String getPortletId(HttpServletRequest request) {
2442        PortletConfigImpl portletConfigImpl =
2443            (PortletConfigImpl)request.getAttribute(
2444                JavaConstants.JAVAX_PORTLET_CONFIG);
2445
2446        if (portletConfigImpl != null) {
2447            return portletConfigImpl.getPortletId();
2448        }
2449        else {
2450            return null;
2451        }
2452    }
2453
2454    public String getPortletId(PortletRequest portletRequest) {
2455        PortletConfigImpl portletConfigImpl =
2456            (PortletConfigImpl)portletRequest.getAttribute(
2457                JavaConstants.JAVAX_PORTLET_CONFIG);
2458
2459        if (portletConfigImpl != null) {
2460            return portletConfigImpl.getPortletId();
2461        }
2462        else {
2463            return null;
2464        }
2465    }
2466
2467    public String getPortletNamespace(String portletId) {
2468        return StringPool.UNDERLINE.concat(portletId).concat(
2469            StringPool.UNDERLINE);
2470    }
2471
2472    public String getPortletTitle(Portlet portlet, Locale locale) {
2473        return getPortletTitle(portlet.getPortletId(), locale);
2474    }
2475
2476    public String getPortletTitle(Portlet portlet, String languageId) {
2477        return getPortletTitle(portlet.getPortletId(), languageId);
2478    }
2479
2480    public String getPortletTitle(
2481        Portlet portlet, ServletContext servletContext, Locale locale) {
2482
2483        PortletConfig portletConfig = PortletConfigFactory.create(
2484            portlet, servletContext);
2485
2486        ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
2487
2488        return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
2489    }
2490
2491    public String getPortletTitle(Portlet portlet, User user) {
2492        return getPortletTitle(portlet.getPortletId(), user);
2493    }
2494
2495    public String getPortletTitle(RenderResponse renderResponse) {
2496        PortletResponseImpl portletResponseImpl =
2497            PortletResponseImpl.getPortletResponseImpl(renderResponse);
2498
2499        return ((RenderResponseImpl)portletResponseImpl).getTitle();
2500    }
2501
2502    public String getPortletTitle(String portletId, Locale locale) {
2503        return LanguageUtil.get(
2504            locale,
2505            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
2506                portletId));
2507    }
2508
2509    public String getPortletTitle(String portletId, String languageId) {
2510        Locale locale = LocaleUtil.fromLanguageId(languageId);
2511
2512        return getPortletTitle(portletId, locale);
2513    }
2514
2515    public String getPortletTitle(String portletId, User user) {
2516        return LanguageUtil.get(
2517            user.getLocale(),
2518            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
2519                portletId));
2520    }
2521
2522    public String getPortletXmlFileName() throws SystemException {
2523        if (PrefsPropsUtil.getBoolean(
2524                PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
2525                PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
2526
2527            return PORTLET_XML_FILE_NAME_CUSTOM;
2528        }
2529        else {
2530            return PORTLET_XML_FILE_NAME_STANDARD;
2531        }
2532    }
2533
2534    public PortletPreferences getPreferences(HttpServletRequest request) {
2535        RenderRequest renderRequest = (RenderRequest)request.getAttribute(
2536            JavaConstants.JAVAX_PORTLET_REQUEST);
2537
2538        PortletPreferences preferences = null;
2539
2540        if (renderRequest != null) {
2541            PortletPreferencesWrapper preferencesWrapper =
2542                (PortletPreferencesWrapper)renderRequest.getPreferences();
2543
2544            preferences = preferencesWrapper.getPreferencesImpl();
2545        }
2546
2547        return preferences;
2548    }
2549
2550    public PreferencesValidator getPreferencesValidator(Portlet portlet) {
2551        PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
2552
2553        return portletBag.getPreferencesValidatorInstance();
2554    }
2555
2556    public long getScopeGroupId(HttpServletRequest request)
2557        throws PortalException, SystemException {
2558
2559        String portletId = getPortletId(request);
2560
2561        return getScopeGroupId(request, portletId);
2562    }
2563
2564    public long getScopeGroupId(HttpServletRequest request, String portletId)
2565        throws PortalException, SystemException {
2566
2567        Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2568
2569        long scopeGroupId = 0;
2570
2571        if (layout != null) {
2572            Group group = layout.getGroup();
2573
2574            if (group.isControlPanel()) {
2575                long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
2576
2577                if (doAsGroupId <= 0) {
2578                    try {
2579                        Group guestGroup = GroupLocalServiceUtil.getGroup(
2580                            group.getCompanyId(), GroupConstants.GUEST);
2581
2582                        doAsGroupId = guestGroup.getGroupId();
2583                    }
2584                    catch (Exception e) {
2585                    }
2586                }
2587
2588                if (doAsGroupId > 0) {
2589                    scopeGroupId = doAsGroupId;
2590                }
2591
2592                try {
2593                    group = GroupLocalServiceUtil.getGroup(scopeGroupId);
2594
2595                    if (group.hasStagingGroup()) {
2596                        Group stagingGroup = group.getStagingGroup();
2597
2598                        scopeGroupId = stagingGroup.getGroupId();
2599                    }
2600                }
2601                catch (Exception e) {
2602                }
2603            }
2604        }
2605
2606        if (scopeGroupId <= 0) {
2607            scopeGroupId = getScopeGroupId(layout, portletId);
2608        }
2609
2610        return scopeGroupId;
2611    }
2612
2613    public long getScopeGroupId(Layout layout) {
2614        if (layout == null) {
2615            return 0;
2616        }
2617        else {
2618            return layout.getGroupId();
2619        }
2620    }
2621
2622    public long getScopeGroupId(Layout layout, String portletId) {
2623        if (layout == null) {
2624            return 0;
2625        }
2626        else {
2627            if (Validator.isNotNull(portletId)) {
2628                try {
2629                    PortletPreferences portletSetup =
2630                        PortletPreferencesFactoryUtil.getLayoutPortletSetup(
2631                            layout, portletId);
2632
2633                    long scopeLayoutId = GetterUtil.getLong(
2634                        portletSetup.getValue("lfr-scope-layout-id", null));
2635
2636                    if (scopeLayoutId > 0) {
2637                        Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
2638                            layout.getGroupId(), layout.isPrivateLayout(),
2639                            scopeLayoutId);
2640
2641                        return scopeLayout.getScopeGroup().getGroupId();
2642                    }
2643                }
2644                catch (Exception e) {
2645                }
2646            }
2647
2648            return layout.getGroupId();
2649        }
2650    }
2651
2652    public long getScopeGroupId(long plid) {
2653        Layout layout = null;
2654
2655        try {
2656            layout = LayoutLocalServiceUtil.getLayout(plid);
2657        }
2658        catch (Exception e) {
2659        }
2660
2661        return getScopeGroupId(layout);
2662    }
2663
2664    public long getScopeGroupId(PortletRequest portletRequest)
2665        throws PortalException, SystemException {
2666
2667        return getScopeGroupId(getHttpServletRequest(portletRequest));
2668    }
2669
2670    public User getSelectedUser(HttpServletRequest request)
2671        throws PortalException, SystemException {
2672
2673        return getSelectedUser(request, true);
2674    }
2675
2676    public User getSelectedUser(
2677            HttpServletRequest request, boolean checkPermission)
2678        throws PortalException, SystemException {
2679
2680        long userId = ParamUtil.getLong(request, "p_u_i_d");
2681
2682        User user = null;
2683
2684        try {
2685            if (checkPermission) {
2686                user = UserServiceUtil.getUserById(userId);
2687            }
2688            else {
2689                user = UserLocalServiceUtil.getUserById(userId);
2690            }
2691        }
2692        catch (NoSuchUserException nsue) {
2693        }
2694
2695        return user;
2696    }
2697
2698    public User getSelectedUser(PortletRequest portletRequest)
2699        throws PortalException, SystemException {
2700
2701        return getSelectedUser(portletRequest, true);
2702    }
2703
2704    public User getSelectedUser(
2705            PortletRequest portletRequest, boolean checkPermission)
2706        throws PortalException, SystemException {
2707
2708        return getSelectedUser(
2709            getHttpServletRequest(portletRequest), checkPermission);
2710    }
2711
2712    public ServletContext getServletContext(
2713        Portlet portlet, ServletContext servletContext) {
2714
2715        PortletConfig portletConfig = PortletConfigFactory.create(
2716            portlet, servletContext);
2717
2718        PortletContextImpl portletContextImpl =
2719            (PortletContextImpl)portletConfig.getPortletContext();
2720
2721        return portletContextImpl.getServletContext();
2722    }
2723
2724    public SocialEquityActionMapping getSocialEquityActionMapping(
2725        String name, String actionId) {
2726
2727        return ResourceActionsUtil.getSocialEquityActionMapping(name, actionId);
2728    }
2729
2730    public List<SocialEquityActionMapping> getSocialEquityActionMappings(
2731        String name) {
2732
2733        return ResourceActionsUtil.getSocialEquityActionMappings(name);
2734    }
2735
2736    public String[] getSocialEquityClassNames() {
2737        return ResourceActionsUtil.getSocialEquityClassNames();
2738    }
2739
2740    public String getStaticResourceURL(
2741        HttpServletRequest request, String uri) {
2742
2743        return getStaticResourceURL(request, uri, null, 0);
2744    }
2745
2746    public String getStaticResourceURL(
2747        HttpServletRequest request, String uri, long timestamp) {
2748
2749        return getStaticResourceURL(request, uri, null, timestamp);
2750    }
2751
2752    public String getStaticResourceURL(
2753        HttpServletRequest request, String uri, String queryString) {
2754
2755        return getStaticResourceURL(request, uri, queryString, 0);
2756    }
2757
2758    public String getStaticResourceURL(
2759        HttpServletRequest request, String uri, String queryString,
2760        long timestamp) {
2761
2762        if (uri.contains(StringPool.QUESTION)) {
2763            return uri;
2764        }
2765
2766        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2767            WebKeys.THEME_DISPLAY);
2768
2769        Theme theme = themeDisplay.getTheme();
2770        ColorScheme colorScheme = themeDisplay.getColorScheme();
2771
2772        Map<String, String[]> parameterMap = null;
2773
2774        if (Validator.isNotNull(queryString)) {
2775            parameterMap = HttpUtil.getParameterMap(queryString);
2776        }
2777
2778        StringBundler sb = new StringBundler();
2779
2780        // URI
2781
2782        sb.append(uri);
2783        sb.append(StringPool.QUESTION);
2784
2785        // Browser id
2786
2787        if ((parameterMap == null) ||
2788            (!parameterMap.containsKey("browserId"))) {
2789
2790            sb.append("&browserId=");
2791            sb.append(BrowserSnifferUtil.getBrowserId(request));
2792        }
2793
2794        // Theme and color scheme
2795
2796        if (uri.endsWith(".jsp")) {
2797            if ((parameterMap == null) ||
2798                (!parameterMap.containsKey("themeId"))) {
2799
2800                sb.append("&themeId=");
2801                sb.append(theme.getThemeId());
2802            }
2803
2804            if ((parameterMap == null) ||
2805                (!parameterMap.containsKey("colorSchemeId"))) {
2806
2807                sb.append("&colorSchemeId=");
2808                sb.append(colorScheme.getColorSchemeId());
2809            }
2810        }
2811
2812        // Minifier
2813
2814        if ((parameterMap == null) ||
2815            (!parameterMap.containsKey("minifierType"))) {
2816
2817            String minifierType = StringPool.BLANK;
2818
2819            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
2820                uri.endsWith("css/main.jsp")) {
2821
2822                if (themeDisplay.isThemeCssFastLoad()) {
2823                    minifierType = "css";
2824                }
2825            }
2826            else if (themeDisplay.isThemeJsFastLoad()) {
2827                minifierType = "js";
2828            }
2829
2830            if (Validator.isNotNull(minifierType)) {
2831                sb.append("&minifierType=");
2832                sb.append(minifierType);
2833            }
2834        }
2835
2836        // Query string
2837
2838        if (Validator.isNotNull(queryString)) {
2839            if (!queryString.startsWith(StringPool.AMPERSAND)) {
2840                sb.append(StringPool.AMPERSAND);
2841            }
2842
2843            sb.append(queryString);
2844        }
2845
2846        // Language id
2847
2848        sb.append("&languageId=");
2849        sb.append(themeDisplay.getLanguageId());
2850
2851        // Timestamp
2852
2853        if ((parameterMap == null) || !parameterMap.containsKey("t")) {
2854            if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
2855                ServletContext servletContext =
2856                    (ServletContext)request.getAttribute(WebKeys.CTX);
2857
2858                String uriRealPath = ServletContextUtil.getRealPath(
2859                    servletContext, uri);
2860
2861                if (uriRealPath != null) {
2862                    File uriFile = new File(uriRealPath);
2863
2864                    if (uriFile.exists()) {
2865                        timestamp = uriFile.lastModified();
2866                    }
2867                }
2868            }
2869
2870            if (timestamp == 0) {
2871                timestamp = theme.getTimestamp();
2872            }
2873
2874            sb.append("&t=");
2875            sb.append(timestamp);
2876        }
2877
2878        String url = sb.toString();
2879
2880        url = StringUtil.replace(url, "?&", StringPool.QUESTION);
2881
2882        return url;
2883    }
2884
2885    public String getStrutsAction(HttpServletRequest request) {
2886        String strutsAction = ParamUtil.getString(request, "struts_action");
2887
2888        if (Validator.isNotNull(strutsAction)) {
2889
2890            // This method should only return a Struts action if you're dealing
2891            // with a regular HTTP servlet request, not a portlet HTTP servlet
2892            // request.
2893
2894            return StringPool.BLANK;
2895        }
2896
2897        return _getPortletParam(request, "struts_action");
2898    }
2899
2900    public String[] getSystemCommunityRoles() {
2901        return _allSystemCommunityRoles;
2902    }
2903
2904    public String[] getSystemGroups() {
2905        return _allSystemGroups;
2906    }
2907
2908    public String[] getSystemOrganizationRoles() {
2909        return _allSystemOrganizationRoles;
2910    }
2911
2912    public String[] getSystemRoles() {
2913        return _allSystemRoles;
2914    }
2915
2916    public UploadServletRequest getUploadServletRequest(
2917        HttpServletRequest request) {
2918
2919        HttpServletRequestWrapper requestWrapper = null;
2920
2921        if (request instanceof HttpServletRequestWrapper) {
2922            requestWrapper = (HttpServletRequestWrapper)request;
2923        }
2924
2925        UploadServletRequest uploadRequest = null;
2926
2927        while (uploadRequest == null) {
2928
2929            // Find the underlying UploadServletRequest wrapper. For example,
2930            // WebSphere wraps all requests with ProtectedServletRequest.
2931
2932            if (requestWrapper instanceof UploadServletRequest) {
2933                uploadRequest = (UploadServletRequest)requestWrapper;
2934            }
2935            else {
2936                HttpServletRequest parentRequest =
2937                    (HttpServletRequest)requestWrapper.getRequest();
2938
2939                if (!(parentRequest instanceof HttpServletRequestWrapper)) {
2940
2941                    // This block should never be reached unless this method is
2942                    // called from a hot deployable portlet. See LayoutAction.
2943
2944                    uploadRequest = new UploadServletRequestImpl(parentRequest);
2945
2946                    break;
2947                }
2948                else {
2949                    requestWrapper = (HttpServletRequestWrapper)parentRequest;
2950                }
2951            }
2952        }
2953
2954        return uploadRequest;
2955    }
2956
2957    public UploadPortletRequest getUploadPortletRequest(
2958        PortletRequest portletRequest) {
2959
2960        PortletRequestImpl portletRequestImpl =
2961            (PortletRequestImpl)portletRequest;
2962
2963        DynamicServletRequest dynamicRequest =
2964            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
2965
2966        HttpServletRequestWrapper requestWrapper =
2967            (HttpServletRequestWrapper)dynamicRequest.getRequest();
2968
2969        UploadServletRequest uploadRequest = getUploadServletRequest(
2970            requestWrapper);
2971
2972        return new UploadPortletRequestImpl(
2973            uploadRequest,
2974            PortalUtil.getPortletNamespace(
2975                portletRequestImpl.getPortletName()));
2976    }
2977
2978    public Date getUptime() {
2979        return _UP_TIME;
2980    }
2981
2982    public String getURLWithSessionId(String url, String sessionId) {
2983        if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
2984            return url;
2985        }
2986
2987        // LEP-4787
2988
2989        int x = url.indexOf(StringPool.SEMICOLON);
2990
2991        if (x != -1) {
2992            return url;
2993        }
2994
2995        x = url.indexOf(StringPool.QUESTION);
2996
2997        if (x != -1) {
2998            StringBundler sb = new StringBundler(4);
2999
3000            sb.append(url.substring(0, x));
3001            sb.append(_JSESSIONID);
3002            sb.append(sessionId);
3003            sb.append(url.substring(x));
3004
3005            return sb.toString();
3006        }
3007
3008        // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
3009        // http://www.abc.com/;jsessionid=XYZ does work.
3010
3011        x = url.indexOf(StringPool.DOUBLE_SLASH);
3012
3013        StringBundler sb = new StringBundler(4);
3014
3015        sb.append(url);
3016
3017        if (x != -1) {
3018            int y = url.lastIndexOf(StringPool.SLASH);
3019
3020            if (x + 1 == y) {
3021                sb.append(StringPool.SLASH);
3022            }
3023        }
3024
3025        sb.append(_JSESSIONID);
3026        sb.append(sessionId);
3027
3028        return sb.toString();
3029    }
3030
3031    public User getUser(HttpServletRequest request)
3032        throws PortalException, SystemException {
3033
3034        long userId = getUserId(request);
3035
3036        if (userId <= 0) {
3037
3038            // Portlet WARs may have the correct remote user and not have the
3039            // correct user id because the user id is saved in the session
3040            // and may not be accessible by the portlet WAR's session. This
3041            // behavior is inconsistent across different application servers.
3042
3043            String remoteUser = request.getRemoteUser();
3044
3045            if (remoteUser == null) {
3046                return null;
3047            }
3048
3049            userId = GetterUtil.getLong(remoteUser);
3050        }
3051
3052        User user = (User)request.getAttribute(WebKeys.USER);
3053
3054        if (user == null) {
3055            user = UserLocalServiceUtil.getUserById(userId);
3056
3057            request.setAttribute(WebKeys.USER, user);
3058        }
3059
3060        return user;
3061    }
3062
3063    public User getUser(PortletRequest portletRequest)
3064        throws PortalException, SystemException {
3065
3066        return getUser(getHttpServletRequest(portletRequest));
3067    }
3068
3069    public long getUserId(HttpServletRequest request) {
3070        Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
3071
3072        if (userIdObj != null) {
3073            return userIdObj.longValue();
3074        }
3075
3076        String path = GetterUtil.getString(request.getPathInfo());
3077        String strutsAction = getStrutsAction(request);
3078        String actionName = _getPortletParam(request, "actionName");
3079
3080        boolean alwaysAllowDoAsUser = false;
3081
3082        if (path.equals("/portal/fckeditor") ||
3083            strutsAction.equals("/document_library/edit_file_entry") ||
3084            strutsAction.equals("/image_gallery/edit_image") ||
3085            strutsAction.equals("/wiki/edit_page_attachment") ||
3086            actionName.equals("addFile")) {
3087
3088            alwaysAllowDoAsUser = true;
3089        }
3090
3091        if ((!PropsValues.PORTAL_JAAS_ENABLE &&
3092              PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
3093            (alwaysAllowDoAsUser)) {
3094
3095            String doAsUserIdString = ParamUtil.getString(
3096                request, "doAsUserId");
3097
3098            try {
3099                long doAsUserId = getDoAsUserId(
3100                    request, doAsUserIdString, alwaysAllowDoAsUser);
3101
3102                if (doAsUserId > 0) {
3103                    if (_log.isDebugEnabled()) {
3104                        _log.debug("Impersonating user " + doAsUserId);
3105                    }
3106
3107                    return doAsUserId;
3108                }
3109            }
3110            catch (Exception e) {
3111                _log.error("Unable to impersonate user " + doAsUserIdString, e);
3112            }
3113        }
3114
3115        HttpSession session = request.getSession();
3116
3117        userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
3118
3119        if (userIdObj != null) {
3120            request.setAttribute(WebKeys.USER_ID, userIdObj);
3121
3122            return userIdObj.longValue();
3123        }
3124        else {
3125            return 0;
3126        }
3127    }
3128
3129    public long getUserId(PortletRequest portletRequest) {
3130        return getUserId(getHttpServletRequest(portletRequest));
3131    }
3132
3133    public String getUserName(long userId, String defaultUserName) {
3134        return getUserName(
3135            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
3136    }
3137
3138    public String getUserName(
3139        long userId, String defaultUserName, HttpServletRequest request) {
3140
3141        return getUserName(
3142            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
3143    }
3144
3145    public String getUserName(
3146        long userId, String defaultUserName, String userAttribute) {
3147
3148        return getUserName(userId, defaultUserName, userAttribute, null);
3149    }
3150
3151    public String getUserName(
3152        long userId, String defaultUserName, String userAttribute,
3153        HttpServletRequest request) {
3154
3155        String userName = defaultUserName;
3156
3157        try {
3158            User user = UserLocalServiceUtil.getUserById(userId);
3159
3160            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
3161                userName = user.getFullName();
3162            }
3163            else {
3164                userName = user.getScreenName();
3165            }
3166
3167            if (request != null) {
3168                Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3169
3170                PortletURL portletURL = new PortletURLImpl(
3171                    request, PortletKeys.DIRECTORY, layout.getPlid(),
3172                    PortletRequest.RENDER_PHASE);
3173
3174                portletURL.setWindowState(WindowState.MAXIMIZED);
3175                portletURL.setPortletMode(PortletMode.VIEW);
3176
3177                portletURL.setParameter(
3178                    "struts_action", "/directory/view_user");
3179                portletURL.setParameter(
3180                    "p_u_i_d", String.valueOf(user.getUserId()));
3181
3182                userName =
3183                    "<a href=\"" + portletURL.toString() + "\">" +
3184                        HtmlUtil.escape(userName) + "</a>";
3185            }
3186        }
3187        catch (Exception e) {
3188        }
3189
3190        return userName;
3191    }
3192
3193    public String getUserPassword(HttpServletRequest request) {
3194        HttpSession session = request.getSession();
3195
3196        return getUserPassword(session);
3197    }
3198
3199    public String getUserPassword(HttpSession session) {
3200        return (String)session.getAttribute(WebKeys.USER_PASSWORD);
3201    }
3202
3203    public String getUserPassword(PortletRequest portletRequest) {
3204        return getUserPassword(getHttpServletRequest(portletRequest));
3205    }
3206
3207    public String getUserValue(long userId, String param, String defaultValue)
3208        throws SystemException {
3209
3210        if (Validator.isNotNull(defaultValue)) {
3211            return defaultValue;
3212        }
3213        else {
3214            try {
3215                User user = UserLocalServiceUtil.getUserById(userId);
3216
3217                return BeanPropertiesUtil.getString(user, param, defaultValue);
3218            }
3219            catch (PortalException pe) {
3220                return StringPool.BLANK;
3221            }
3222        }
3223    }
3224
3225    public long getValidUserId(long companyId, long userId)
3226        throws PortalException, SystemException {
3227
3228        try {
3229            User user = UserLocalServiceUtil.getUser(userId);
3230
3231            if (user.getCompanyId() == companyId) {
3232                return user.getUserId();
3233            }
3234            else {
3235                return userId;
3236            }
3237        }
3238        catch (NoSuchUserException nsue) {
3239            return UserLocalServiceUtil.getDefaultUserId(companyId);
3240        }
3241    }
3242
3243    public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
3244        throws PortalException, SystemException {
3245
3246        return _getServletURL(
3247            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
3248    }
3249
3250    public boolean isAllowAddPortletDefaultResource(
3251            HttpServletRequest request, Portlet portlet)
3252        throws PortalException, SystemException {
3253
3254        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3255            WebKeys.THEME_DISPLAY);
3256
3257        Layout layout = themeDisplay.getLayout();
3258        LayoutTypePortlet layoutTypePortlet =
3259            themeDisplay.getLayoutTypePortlet();
3260
3261        String portletId = portlet.getPortletId();
3262
3263        Boolean renderPortletResource = (Boolean)request.getAttribute(
3264            WebKeys.RENDER_PORTLET_RESOURCE);
3265
3266        if (renderPortletResource != null) {
3267            boolean runtimePortlet = renderPortletResource.booleanValue();
3268
3269            if (runtimePortlet) {
3270                return true;
3271            }
3272        }
3273
3274        if (layout.isTypePanel()) {
3275            return true;
3276        }
3277
3278        if (layout.isTypeControlPanel()) {
3279            return true;
3280        }
3281
3282        if (layoutTypePortlet.hasPortletId(portletId)) {
3283            return true;
3284        }
3285
3286        if (themeDisplay.isSignedIn() &&
3287            (portletId.equals(PortletKeys.LAYOUT_CONFIGURATION) ||
3288             portletId.equals(PortletKeys.LAYOUT_MANAGEMENT))) {
3289
3290            PermissionChecker permissionChecker =
3291                themeDisplay.getPermissionChecker();
3292
3293            Group group = layout.getGroup();
3294
3295            if (group.isCommunity() || group.isUserGroup()) {
3296                long scopeGroupId = themeDisplay.getScopeGroupId();
3297
3298                if (GroupPermissionUtil.contains(
3299                        permissionChecker, scopeGroupId,
3300                        ActionKeys.MANAGE_LAYOUTS) ||
3301                    GroupPermissionUtil.contains(
3302                        permissionChecker, scopeGroupId,
3303                        ActionKeys.PUBLISH_STAGING) ||
3304                    LayoutPermissionUtil.contains(
3305                        permissionChecker, layout, ActionKeys.UPDATE)) {
3306
3307                    return true;
3308                }
3309            }
3310            else if (group.isCompany()) {
3311                if (permissionChecker.isCompanyAdmin()) {
3312                    return true;
3313                }
3314            }
3315            else if (group.isLayoutPrototype()) {
3316                long layoutPrototypeId = group.getClassPK();
3317
3318                if (LayoutPrototypePermissionUtil.contains(
3319                        permissionChecker, layoutPrototypeId,
3320                        ActionKeys.UPDATE)) {
3321
3322                    return true;
3323                }
3324            }
3325            else if (group.isLayoutSetPrototype()) {
3326                long layoutSetPrototypeId = group.getClassPK();
3327
3328                if (LayoutSetPrototypePermissionUtil.contains(
3329                        permissionChecker, layoutSetPrototypeId,
3330                        ActionKeys.UPDATE)) {
3331
3332                    return true;
3333                }
3334            }
3335            else if (group.isOrganization()) {
3336                long organizationId = group.getClassPK();
3337
3338                if (OrganizationPermissionUtil.contains(
3339                        permissionChecker, organizationId,
3340                        ActionKeys.MANAGE_LAYOUTS)) {
3341
3342                    return true;
3343                }
3344            }
3345            else if (group.isUser()) {
3346                return true;
3347            }
3348        }
3349
3350        if (portlet.isAddDefaultResource()) {
3351            if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
3352                return true;
3353            }
3354
3355            if (_portletAddDefaultResourceCheckWhitelist.contains(portletId)) {
3356                return true;
3357            }
3358
3359            String strutsAction = ParamUtil.getString(request, "struts_action");
3360
3361            if (_portletAddDefaultResourceCheckWhitelistActions.contains(
3362                    strutsAction)) {
3363
3364                return true;
3365            }
3366
3367            String requestPortletAuthenticationToken = ParamUtil.getString(
3368                request, "p_p_auth");
3369
3370            if (Validator.isNotNull(requestPortletAuthenticationToken)) {
3371                String actualPortletAuthenticationToken =
3372                    AuthTokenUtil.getToken(
3373                        request, layout.getPlid(), portletId);
3374
3375                if (requestPortletAuthenticationToken.equals(
3376                        actualPortletAuthenticationToken)) {
3377
3378                    return true;
3379                }
3380            }
3381        }
3382
3383        return false;
3384    }
3385
3386    public boolean isCommunityAdmin(User user, long groupId) throws Exception {
3387        PermissionChecker permissionChecker =
3388            PermissionCheckerFactoryUtil.create(user, true);
3389
3390        return permissionChecker.isCommunityAdmin(groupId);
3391    }
3392
3393    public boolean isCommunityOwner(User user, long groupId) throws Exception {
3394        PermissionChecker permissionChecker =
3395            PermissionCheckerFactoryUtil.create(user, true);
3396
3397        return permissionChecker.isCommunityOwner(groupId);
3398    }
3399
3400    public boolean isCompanyAdmin(User user) throws Exception {
3401        PermissionChecker permissionChecker =
3402            PermissionCheckerFactoryUtil.create(user, true);
3403
3404        return permissionChecker.isCompanyAdmin();
3405    }
3406
3407    public boolean isLayoutFirstPageable(Layout layout) {
3408        LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3409
3410        return layoutSettings.isFirstPageable();
3411    }
3412
3413    public boolean isLayoutFirstPageable(String type) {
3414        LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3415
3416        return layoutSettings.isFirstPageable();
3417    }
3418
3419    public boolean isLayoutFriendliable(Layout layout) {
3420        LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3421
3422        return layoutSettings.isURLFriendliable();
3423    }
3424
3425    public boolean isLayoutFriendliable(String type) {
3426        LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3427
3428        return layoutSettings.isURLFriendliable();
3429    }
3430
3431    public boolean isLayoutParentable(Layout layout) {
3432        return isLayoutParentable(layout.getType());
3433    }
3434
3435    public boolean isLayoutParentable(String type) {
3436        LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3437
3438        return layoutSettings.isParentable();
3439    }
3440
3441    public boolean isLayoutSitemapable(Layout layout) {
3442        if (layout.isPrivateLayout()) {
3443            return false;
3444        }
3445
3446        LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3447
3448        return layoutSettings.isSitemapable();
3449    }
3450
3451    public boolean isMethodGet(PortletRequest portletRequest) {
3452        HttpServletRequest request = getHttpServletRequest(portletRequest);
3453
3454        String method = GetterUtil.getString(request.getMethod());
3455
3456        if (method.equalsIgnoreCase(HttpMethods.GET)) {
3457            return true;
3458        }
3459        else {
3460            return false;
3461        }
3462    }
3463
3464    public boolean isMethodPost(PortletRequest portletRequest) {
3465        HttpServletRequest request = getHttpServletRequest(portletRequest);
3466
3467        String method = GetterUtil.getString(request.getMethod());
3468
3469        if (method.equalsIgnoreCase(HttpMethods.POST)) {
3470            return true;
3471        }
3472        else {
3473            return false;
3474        }
3475    }
3476
3477    public boolean isOmniadmin(long userId) {
3478        return OmniadminUtil.isOmniadmin(userId);
3479    }
3480
3481    public boolean isReservedParameter(String name) {
3482        return _reservedParams.contains(name);
3483    }
3484
3485    public boolean isSystemGroup(String groupName) {
3486        if (groupName == null) {
3487            return false;
3488        }
3489
3490        groupName = groupName.trim();
3491
3492        int pos = Arrays.binarySearch(
3493            _sortedSystemGroups, groupName, new StringComparator());
3494
3495        if (pos >= 0) {
3496            return true;
3497        }
3498        else {
3499            return false;
3500        }
3501    }
3502
3503    public boolean isSystemRole(String roleName) {
3504        if (roleName == null) {
3505            return false;
3506        }
3507
3508        roleName = roleName.trim();
3509
3510        int pos = Arrays.binarySearch(
3511            _sortedSystemRoles, roleName, new StringComparator());
3512
3513        if (pos >= 0) {
3514            return true;
3515        }
3516        else {
3517            pos = Arrays.binarySearch(
3518                _sortedSystemCommunityRoles, roleName, new StringComparator());
3519
3520            if (pos >= 0) {
3521                return true;
3522            }
3523            else {
3524                pos = Arrays.binarySearch(
3525                    _sortedSystemOrganizationRoles, roleName,
3526                    new StringComparator());
3527
3528                if (pos >= 0) {
3529                    return true;
3530                }
3531            }
3532        }
3533
3534        return false;
3535    }
3536
3537    public boolean isUpdateAvailable() throws SystemException {
3538        return PluginPackageUtil.isUpdateAvailable();
3539    }
3540
3541    public String renderPage(
3542            ServletContext servletContext, HttpServletRequest request,
3543            HttpServletResponse response, String path)
3544        throws IOException, ServletException {
3545
3546        RequestDispatcher requestDispatcher =
3547            servletContext.getRequestDispatcher(path);
3548
3549        StringServletResponse stringResponse = new StringServletResponse(
3550            response);
3551
3552        requestDispatcher.include(request, stringResponse);
3553
3554        return stringResponse.getString();
3555    }
3556
3557    public String renderPortlet(
3558            ServletContext servletContext, HttpServletRequest request,
3559            HttpServletResponse response, Portlet portlet, String queryString,
3560            boolean writeOutput)
3561        throws IOException, ServletException {
3562
3563        return renderPortlet(
3564            servletContext, request, response, portlet, queryString, null, null,
3565            null, writeOutput);
3566    }
3567
3568    public String renderPortlet(
3569            ServletContext servletContext, HttpServletRequest request,
3570            HttpServletResponse response, Portlet portlet, String queryString,
3571            String columnId, Integer columnPos, Integer columnCount,
3572            boolean writeOutput)
3573        throws IOException, ServletException {
3574
3575        return renderPortlet(
3576            servletContext, request, response, portlet, queryString, columnId,
3577            columnPos, columnCount, null, writeOutput);
3578    }
3579
3580    public String renderPortlet(
3581            ServletContext servletContext, HttpServletRequest request,
3582            HttpServletResponse response, Portlet portlet, String queryString,
3583            String columnId, Integer columnPos, Integer columnCount,
3584            String path, boolean writeOutput)
3585        throws IOException, ServletException {
3586
3587        queryString = GetterUtil.getString(queryString);
3588        columnId = GetterUtil.getString(columnId);
3589
3590        if (columnPos == null) {
3591            columnPos = Integer.valueOf(0);
3592        }
3593
3594        if (columnCount == null) {
3595            columnCount = Integer.valueOf(0);
3596        }
3597
3598        request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
3599        request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
3600        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
3601        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
3602        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
3603
3604        if (path == null) {
3605            path = "/html/portal/render_portlet.jsp";
3606        }
3607
3608        RequestDispatcher requestDispatcher =
3609            servletContext.getRequestDispatcher(path);
3610
3611        UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
3612
3613        PipingServletResponse pipingServletResponse = new PipingServletResponse(
3614            response, unsyncStringWriter);
3615
3616        requestDispatcher.include(request, pipingServletResponse);
3617
3618        boolean showPortlet = true;
3619
3620        Boolean portletConfiguratorVisibility = (Boolean)request.getAttribute(
3621            WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
3622
3623        if (portletConfiguratorVisibility != null) {
3624            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3625                WebKeys.THEME_DISPLAY);
3626
3627            try {
3628                if (!PortletPermissionUtil.contains(
3629                        themeDisplay.getPermissionChecker(),
3630                        themeDisplay.getPlid(), portlet.getPortletId(),
3631                        ActionKeys.CONFIGURATION)) {
3632
3633                    showPortlet = false;
3634                }
3635            }
3636            catch (Exception e) {
3637                throw new ServletException(e);
3638            }
3639
3640            request.removeAttribute(WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
3641        }
3642
3643        if (showPortlet) {
3644            if (writeOutput) {
3645                response.setContentType(ContentTypes.TEXT_HTML_UTF8);
3646
3647                StringBundler sb = unsyncStringWriter.getStringBundler();
3648
3649                sb.writeTo(response.getWriter());
3650
3651                return StringPool.BLANK;
3652            }
3653            else {
3654                return unsyncStringWriter.toString();
3655            }
3656        }
3657        else {
3658            return StringPool.BLANK;
3659        }
3660    }
3661
3662    public void sendError(
3663            Exception e, ActionRequest actionRequest,
3664            ActionResponse actionResponse)
3665        throws IOException {
3666
3667        sendError(0, e, actionRequest, actionResponse);
3668    }
3669
3670    public void sendError(
3671            Exception e, HttpServletRequest request,
3672            HttpServletResponse response)
3673        throws IOException, ServletException {
3674
3675        sendError(0, e, request, response);
3676    }
3677
3678    public void sendError(
3679            int status, Exception e, ActionRequest actionRequest,
3680            ActionResponse actionResponse)
3681        throws IOException {
3682
3683        StringBundler sb = new StringBundler(7);
3684
3685        sb.append(_pathMain);
3686        sb.append("/portal/status?status=");
3687        sb.append(status);
3688        sb.append("&exception=");
3689        sb.append(e.getClass().getName());
3690        sb.append("&previousURL=");
3691        sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
3692
3693        actionResponse.sendRedirect(sb.toString());
3694    }
3695
3696    public void sendError(
3697            int status, Exception e, HttpServletRequest request,
3698            HttpServletResponse response)
3699        throws IOException, ServletException {
3700
3701        if (_log.isInfoEnabled()) {
3702            String currentURL = (String)request.getAttribute(
3703                WebKeys.CURRENT_URL);
3704
3705            _log.info(
3706                "Current URL " + currentURL + " generates exception: " +
3707                    e.getMessage());
3708        }
3709
3710        if (e instanceof NoSuchImageException) {
3711            if (_logImageServlet.isWarnEnabled()) {
3712                _logImageServlet.warn(e, e);
3713            }
3714        }
3715        else if ((e instanceof PortalException) && _log.isInfoEnabled()) {
3716            _log.info(e, e);
3717        }
3718        else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
3719            _log.warn(e, e);
3720        }
3721
3722        if (response.isCommitted()) {
3723            return;
3724        }
3725
3726        if (status == 0) {
3727            if (e instanceof PrincipalException) {
3728                status = HttpServletResponse.SC_FORBIDDEN;
3729            }
3730            else {
3731                String name = e.getClass().getName();
3732
3733                name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
3734
3735                if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
3736                    status = HttpServletResponse.SC_NOT_FOUND;
3737                }
3738            }
3739
3740            if (status == 0) {
3741
3742                // LPS-5352
3743
3744                if (PropsValues.TCK_URL) {
3745                    status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
3746                }
3747                else {
3748                    status = HttpServletResponse.SC_BAD_REQUEST;
3749                }
3750            }
3751        }
3752
3753        HttpSession session = request.getSession();
3754
3755        ServletContext servletContext = session.getServletContext();
3756
3757        String redirect = PATH_MAIN + "/portal/status";
3758
3759        if (e instanceof NoSuchLayoutException &&
3760            Validator.isNotNull(
3761                PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
3762
3763            response.setStatus(status);
3764
3765            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
3766
3767            RequestDispatcher requestDispatcher =
3768                servletContext.getRequestDispatcher(redirect);
3769
3770            if (requestDispatcher != null) {
3771                requestDispatcher.forward(request, response);
3772            }
3773        }
3774        else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
3775            response.setStatus(status);
3776
3777            SessionErrors.add(request, e.getClass().getName(), e);
3778
3779            RequestDispatcher requestDispatcher =
3780                servletContext.getRequestDispatcher(redirect);
3781
3782            if (requestDispatcher != null) {
3783                requestDispatcher.forward(request, response);
3784            }
3785        }
3786        else {
3787            if (e != null) {
3788                response.sendError(status, e.getMessage());
3789            }
3790            else {
3791                response.sendError(status);
3792            }
3793        }
3794    }
3795
3796    /**
3797     * Sets the description for a page. This overrides the existing page
3798     * description.
3799     */
3800    public void setPageDescription(
3801        String description, HttpServletRequest request) {
3802
3803        request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
3804    }
3805
3806    /**
3807     * Sets the keywords for a page. This overrides the existing page keywords.
3808     */
3809    public void setPageKeywords(String keywords, HttpServletRequest request) {
3810        request.removeAttribute(WebKeys.PAGE_KEYWORDS);
3811
3812        addPageKeywords(keywords, request);
3813    }
3814
3815    /**
3816     * Sets the subtitle for a page. This overrides the existing page subtitle.
3817     */
3818    public void setPageSubtitle(String subtitle, HttpServletRequest request) {
3819        request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
3820    }
3821
3822    /**
3823     * Sets the whole title for a page. This overrides the existing page whole
3824     * title.
3825     */
3826    public void setPageTitle(String title, HttpServletRequest request) {
3827        request.setAttribute(WebKeys.PAGE_TITLE, title);
3828    }
3829
3830    /**
3831     * Sets the port obtained on the first request to the portal.
3832     */
3833    public void setPortalPort(HttpServletRequest request) {
3834        if (_portalPort == -1) {
3835            _portalPortLock.lock();
3836
3837            try {
3838                if (_portalPort == -1) {
3839                    _portalPort = request.getServerPort();
3840                }
3841            }
3842            finally {
3843                _portalPortLock.unlock();
3844            }
3845        }
3846    }
3847
3848    public void storePreferences(PortletPreferences preferences)
3849        throws IOException, ValidatorException {
3850
3851        PortletPreferencesWrapper preferencesWrapper =
3852            (PortletPreferencesWrapper)preferences;
3853
3854        PortletPreferencesImpl preferencesImpl =
3855            preferencesWrapper.getPreferencesImpl();
3856
3857        preferencesImpl.store();
3858    }
3859
3860    public String transformCustomSQL(String sql) {
3861        if ((_customSqlClassNames == null) ||
3862            (_customSqlClassNameIds == null)) {
3863
3864            _initCustomSQL();
3865        }
3866
3867        return StringUtil.replace(
3868            sql, _customSqlClassNames, _customSqlClassNameIds);
3869    }
3870
3871    public PortletMode updatePortletMode(
3872        String portletId, User user, Layout layout, PortletMode portletMode,
3873        HttpServletRequest request) {
3874
3875        LayoutTypePortlet layoutType =
3876            (LayoutTypePortlet)layout.getLayoutType();
3877
3878        if (portletMode == null || Validator.isNull(portletMode.toString())) {
3879            if (layoutType.hasModeAboutPortletId(portletId)) {
3880                return LiferayPortletMode.ABOUT;
3881            }
3882            else if (layoutType.hasModeConfigPortletId(portletId)) {
3883                return LiferayPortletMode.CONFIG;
3884            }
3885            else if (layoutType.hasModeEditPortletId(portletId)) {
3886                return PortletMode.EDIT;
3887            }
3888            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
3889                return LiferayPortletMode.EDIT_DEFAULTS;
3890            }
3891            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
3892                return LiferayPortletMode.EDIT_GUEST;
3893            }
3894            else if (layoutType.hasModeHelpPortletId(portletId)) {
3895                return PortletMode.HELP;
3896            }
3897            else if (layoutType.hasModePreviewPortletId(portletId)) {
3898                return LiferayPortletMode.PREVIEW;
3899            }
3900            else if (layoutType.hasModePrintPortletId(portletId)) {
3901                return LiferayPortletMode.PRINT;
3902            }
3903            else {
3904                return PortletMode.VIEW;
3905            }
3906        }
3907        else {
3908            boolean updateLayout = false;
3909
3910            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
3911                !layoutType.hasModeAboutPortletId(portletId)) {
3912
3913                layoutType.addModeAboutPortletId(portletId);
3914
3915                updateLayout = true;
3916            }
3917            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
3918                     !layoutType.hasModeConfigPortletId(portletId)) {
3919
3920                layoutType.addModeConfigPortletId(portletId);
3921
3922                updateLayout = true;
3923            }
3924            else if (portletMode.equals(PortletMode.EDIT) &&
3925                     !layoutType.hasModeEditPortletId(portletId)) {
3926
3927                layoutType.addModeEditPortletId(portletId);
3928
3929                updateLayout = true;
3930            }
3931            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
3932                     !layoutType.hasModeEditDefaultsPortletId(portletId)) {
3933
3934                layoutType.addModeEditDefaultsPortletId(portletId);
3935
3936                updateLayout = true;
3937            }
3938            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
3939                     !layoutType.hasModeEditGuestPortletId(portletId)) {
3940
3941                layoutType.addModeEditGuestPortletId(portletId);
3942
3943                updateLayout = true;
3944            }
3945            else if (portletMode.equals(PortletMode.HELP) &&
3946                     !layoutType.hasModeHelpPortletId(portletId)) {
3947
3948                layoutType.addModeHelpPortletId(portletId);
3949
3950                updateLayout = true;
3951            }
3952            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
3953                     !layoutType.hasModePreviewPortletId(portletId)) {
3954
3955                layoutType.addModePreviewPortletId(portletId);
3956
3957                updateLayout = true;
3958            }
3959            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
3960                     !layoutType.hasModePrintPortletId(portletId)) {
3961
3962                layoutType.addModePrintPortletId(portletId);
3963
3964                updateLayout = true;
3965            }
3966            else if (portletMode.equals(PortletMode.VIEW) &&
3967                     !layoutType.hasModeViewPortletId(portletId)) {
3968
3969                layoutType.removeModesPortletId(portletId);
3970
3971                updateLayout = true;
3972            }
3973
3974            if (updateLayout) {
3975                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
3976
3977                if (layoutClone != null) {
3978                    layoutClone.update(
3979                        request, layout.getPlid(), layout.getTypeSettings());
3980                }
3981            }
3982
3983            return portletMode;
3984        }
3985    }
3986
3987    public WindowState updateWindowState(
3988        String portletId, User user, Layout layout, WindowState windowState,
3989        HttpServletRequest request) {
3990
3991        LayoutTypePortlet layoutType =
3992            (LayoutTypePortlet)layout.getLayoutType();
3993
3994        if ((windowState == null) ||
3995            (Validator.isNull(windowState.toString()))) {
3996
3997            if (layoutType.hasStateMaxPortletId(portletId)) {
3998                windowState = WindowState.MAXIMIZED;
3999            }
4000            else if (layoutType.hasStateMinPortletId(portletId)) {
4001                windowState = WindowState.MINIMIZED;
4002            }
4003            else {
4004                windowState = WindowState.NORMAL;
4005            }
4006        }
4007        else {
4008            boolean updateLayout = false;
4009
4010            if (windowState.equals(WindowState.MAXIMIZED) &&
4011                !layoutType.hasStateMaxPortletId(portletId)) {
4012
4013                layoutType.addStateMaxPortletId(portletId);
4014
4015                if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
4016                    updateLayout = true;
4017                }
4018            }
4019            else if (windowState.equals(WindowState.MINIMIZED) &&
4020                     !layoutType.hasStateMinPortletId(portletId)) {
4021
4022                layoutType.addStateMinPortletId(portletId);
4023
4024                updateLayout = true;
4025            }
4026            else if (windowState.equals(WindowState.NORMAL) &&
4027                     !layoutType.hasStateNormalPortletId(portletId)) {
4028
4029                layoutType.removeStatesPortletId(portletId);
4030
4031                updateLayout = true;
4032            }
4033
4034            if (portletId.equals(PortletKeys.LAYOUT_MANAGEMENT) ||
4035                portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
4036
4037                updateLayout = false;
4038            }
4039
4040            if (updateLayout) {
4041                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
4042
4043                if (layoutClone != null) {
4044                    layoutClone.update(
4045                        request, layout.getPlid(), layout.getTypeSettings());
4046                }
4047            }
4048        }
4049
4050        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4051            WebKeys.THEME_DISPLAY);
4052
4053        themeDisplay.setStateExclusive(
4054            windowState.equals(LiferayWindowState.EXCLUSIVE));
4055        themeDisplay.setStateMaximized(
4056            windowState.equals(WindowState.MAXIMIZED));
4057        themeDisplay.setStatePopUp(
4058            windowState.equals(LiferayWindowState.POP_UP));
4059
4060        if (themeDisplay.isStateMaximized() &&
4061            themeDisplay.isShowAddContentIcon()) {
4062
4063            themeDisplay.setShowAddContentIcon(false);
4064        }
4065        else if (!themeDisplay.isStateMaximized() &&
4066                 !themeDisplay.isShowAddContentIcon() &&
4067                 themeDisplay.isShowAddContentIconPermission()) {
4068
4069            themeDisplay.setShowAddContentIcon(true);
4070        }
4071
4072        request.setAttribute(WebKeys.WINDOW_STATE, windowState);
4073
4074        return windowState;
4075    }
4076
4077    protected List<Portlet> filterControlPanelPortlets(
4078        Set<Portlet> portlets, String category, ThemeDisplay themeDisplay) {
4079
4080        Group group = themeDisplay.getScopeGroup();
4081
4082        List<Portlet> filteredPortlets = new ArrayList<Portlet>();
4083
4084        if (category.equals(PortletCategoryKeys.CONTENT) && group.isLayout()) {
4085            for (Portlet portlet : portlets) {
4086                if (portlet.isScopeable()) {
4087                    filteredPortlets.add(portlet);
4088                }
4089            }
4090        }
4091        else {
4092            filteredPortlets.addAll(portlets);
4093        }
4094
4095        Iterator<Portlet> itr = filteredPortlets.iterator();
4096
4097        while (itr.hasNext()) {
4098            Portlet portlet = itr.next();
4099
4100            try {
4101                ControlPanelEntry controlPanelEntry =
4102                    portlet.getControlPanelEntryInstance();
4103
4104                if (controlPanelEntry == null) {
4105                    controlPanelEntry =
4106                        DefaultControlPanelEntryFactory.getInstance();
4107                }
4108
4109                if (!controlPanelEntry.isVisible(
4110                        portlet, category, themeDisplay)) {
4111
4112                    itr.remove();
4113                }
4114            }
4115            catch (Exception e) {
4116                _log.error(e, e);
4117
4118                itr.remove();
4119            }
4120        }
4121
4122        return filteredPortlets;
4123    }
4124
4125    protected long getDoAsUserId(
4126            HttpServletRequest request, String doAsUserIdString,
4127            boolean alwaysAllowDoAsUser)
4128        throws Exception {
4129
4130        if (Validator.isNull(doAsUserIdString)) {
4131            return 0;
4132        }
4133
4134        long doAsUserId = 0;
4135
4136        try {
4137            Company company = getCompany(request);
4138
4139            doAsUserId = GetterUtil.getLong(
4140                Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
4141        }
4142        catch (Exception e) {
4143            if (_log.isWarnEnabled()) {
4144                _log.warn(
4145                    "Unable to impersonate " + doAsUserIdString +
4146                        " because the string cannot be decrypted",
4147                    e);
4148            }
4149
4150            return 0;
4151        }
4152
4153        if (_log.isDebugEnabled()) {
4154            if (alwaysAllowDoAsUser) {
4155                _log.debug(
4156                    "doAsUserId path or Struts action is always allowed");
4157            }
4158            else {
4159                _log.debug(
4160                    "doAsUserId path is Struts action not always allowed");
4161            }
4162        }
4163
4164        if (alwaysAllowDoAsUser) {
4165            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
4166
4167            return doAsUserId;
4168        }
4169
4170        HttpSession session = request.getSession();
4171
4172        Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
4173
4174        if (realUserIdObj == null) {
4175            return 0;
4176        }
4177
4178        User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
4179
4180        long[] organizationIds = doAsUser.getOrganizationIds();
4181
4182        User realUser = UserLocalServiceUtil.getUserById(
4183            realUserIdObj.longValue());
4184        boolean checkGuest = true;
4185
4186        PermissionChecker permissionChecker =
4187            PermissionCheckerFactoryUtil.create(realUser, checkGuest);
4188
4189        if (doAsUser.isDefaultUser() ||
4190            UserPermissionUtil.contains(
4191                permissionChecker, doAsUserId, organizationIds,
4192                ActionKeys.IMPERSONATE)) {
4193
4194            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
4195
4196            return doAsUserId;
4197        }
4198        else {
4199            _log.error(
4200                "User " + realUserIdObj + " does not have the permission " +
4201                    "to impersonate " + doAsUserId);
4202
4203            return 0;
4204        }
4205    }
4206
4207    private long _getPlidFromPortletId(
4208            long groupId, boolean privateLayout, String portletId)
4209        throws PortalException, SystemException {
4210
4211        long scopeGroupId = groupId;
4212
4213        try {
4214            Group group = GroupLocalServiceUtil.getGroup(groupId);
4215
4216            if (group.isLayout()) {
4217                Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
4218                    group.getClassPK());
4219
4220                groupId = scopeLayout.getGroupId();
4221            }
4222        }
4223        catch (Exception e) {
4224        }
4225
4226        long plid = LayoutConstants.DEFAULT_PLID;
4227
4228        List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
4229            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
4230
4231        for (Layout layout : layouts) {
4232            LayoutTypePortlet layoutTypePortlet =
4233                (LayoutTypePortlet)layout.getLayoutType();
4234
4235            if (layoutTypePortlet.hasPortletId(portletId)) {
4236                if (getScopeGroupId(layout, portletId) == scopeGroupId) {
4237                    plid = layout.getPlid();
4238
4239                    break;
4240                }
4241            }
4242        }
4243
4244        return plid;
4245    }
4246
4247    private String _getPortletParam(HttpServletRequest request, String name) {
4248        String value = null;
4249
4250        int valueCount = 0;
4251
4252        Enumeration<String> enu = request.getParameterNames();
4253
4254        while (enu.hasMoreElements()) {
4255            String curName = enu.nextElement();
4256
4257            int pos = curName.indexOf(StringPool.UNDERLINE + name);
4258
4259            if (pos != -1) {
4260                valueCount++;
4261
4262                // There should never be more than one value
4263
4264                if (valueCount > 1) {
4265                    return StringPool.BLANK;
4266                }
4267
4268                String curValue = ParamUtil.getString(request, curName);
4269
4270                if (Validator.isNotNull(curValue)) {
4271
4272                    // The Struts action must be for the correct portlet
4273
4274                    String portletId1 = curName.substring(1, pos);
4275                    String portletId2 = ParamUtil.getString(request, "p_p_id");
4276
4277                    if (portletId1.equals(portletId2)) {
4278                        value = curValue;
4279                    }
4280                }
4281            }
4282        }
4283
4284        if (value == null) {
4285            value = StringPool.BLANK;
4286        }
4287
4288        return value;
4289    }
4290
4291    private String _getServletURL(
4292            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
4293        throws PortalException, SystemException {
4294
4295        String layoutURL = getLayoutURL(themeDisplay);
4296
4297        Layout layout = themeDisplay.getLayout();
4298
4299        StringBundler sb = new StringBundler();
4300
4301        if (HttpUtil.hasDomain(layoutURL)) {
4302            String protocol = HttpUtil.getProtocol(layoutURL);
4303            String domain = HttpUtil.getDomain(layoutURL);
4304            HttpUtil.removeDomain(layoutURL);
4305
4306            sb.append(protocol);
4307            sb.append(Http.PROTOCOL_DELIMITER);
4308            sb.append(domain);
4309
4310            if (Validator.isNotNull(_pathContext)) {
4311                sb.append(_pathContext);
4312            }
4313
4314            if (themeDisplay.isI18n()) {
4315                sb.append(themeDisplay.getI18nPath());
4316            }
4317
4318            sb.append(servletPath);
4319            sb.append(layout.getFriendlyURL());
4320        }
4321        else {
4322            sb.append(themeDisplay.getPortalURL());
4323
4324            if (Validator.isNotNull(_pathContext)) {
4325                sb.append(_pathContext);
4326            }
4327
4328            if (themeDisplay.isI18n()) {
4329                sb.append(themeDisplay.getI18nPath());
4330            }
4331
4332            sb.append(servletPath);
4333
4334            Group group = layout.getGroup();
4335
4336            if (layout.isPrivateLayout()) {
4337                if (group.isUser()) {
4338                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
4339                }
4340                else {
4341                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
4342                }
4343            }
4344            else {
4345                sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
4346            }
4347
4348            sb.append(group.getFriendlyURL());
4349            sb.append(layout.getFriendlyURL());
4350        }
4351
4352        sb.append(FRIENDLY_URL_SEPARATOR);
4353
4354        FriendlyURLMapper friendlyURLMapper =
4355            portlet.getFriendlyURLMapperInstance();
4356
4357        if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
4358            sb.append(friendlyURLMapper.getMapping());
4359        }
4360        else {
4361            sb.append(portlet.getPortletId());
4362        }
4363
4364        return sb.toString();
4365    }
4366
4367    private void _initCustomSQL() {
4368        _customSqlClassNames = new String[] {
4369            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
4370            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
4371            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
4372            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
4373            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
4374            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
4375            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
4376                "BOOKMARKSENTRY$]",
4377            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
4378            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
4379                "DLFILEENTRY$]",
4380            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
4381            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4382                "MBMESSAGE$]",
4383            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
4384            "[$FALSE$]",
4385            "[$TRUE$]"
4386        };
4387
4388        DB db = DBFactoryUtil.getDB();
4389
4390        _customSqlClassNameIds = new String[] {
4391            String.valueOf(PortalUtil.getClassNameId(Group.class)),
4392            String.valueOf(PortalUtil.getClassNameId(Organization.class)),
4393            String.valueOf(PortalUtil.getClassNameId(Role.class)),
4394            String.valueOf(PortalUtil.getClassNameId(User.class)),
4395            String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
4396            String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
4397            String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
4398            String.valueOf(PortalUtil.getClassNameId(CalEvent.class)),
4399            String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
4400            String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
4401            String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
4402            String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
4403            db.getTemplateFalse(),
4404            db.getTemplateTrue()
4405        };
4406    }
4407
4408    private static final String _J_SECURITY_CHECK = "j_security_check";
4409
4410    private static final String _JSESSIONID = ";jsessionid=";
4411
4412    private static final String _LOCALHOST = "localhost";
4413
4414    private static final String  _PRIVATE_GROUP_SERVLET_MAPPING =
4415        PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
4416
4417    private static final String _PRIVATE_USER_SERVLET_MAPPING =
4418        PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
4419
4420    private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
4421        PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
4422
4423    private static final Date _UP_TIME = new Date();
4424
4425    private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
4426
4427    private static Log _logImageServlet = LogFactoryUtil.getLog(
4428        ImageServlet.class);
4429
4430    private String[] _allSystemCommunityRoles;
4431    private String[] _allSystemGroups;
4432    private String[] _allSystemOrganizationRoles;
4433    private String[] _allSystemRoles;
4434    private String _cdnHostHttp;
4435    private String _cdnHostHttps;
4436    private String _computerAddress;
4437    private String _computerName;
4438    private String[] _customSqlClassNameIds;
4439    private String[] _customSqlClassNames;
4440    private String _globalLibDir;
4441    private String _pathContext;
4442    private String _pathFriendlyURLPrivateGroup;
4443    private String _pathFriendlyURLPrivateUser;
4444    private String _pathFriendlyURLPublic;
4445    private String _pathImage;
4446    private String _pathMain;
4447    private Map<String, Long> _plidToPortletIdCache =
4448        new ConcurrentHashMap<String, Long>();
4449    private String _portalLibDir;
4450    private volatile int _portalPort = -1;
4451    private Lock _portalPortLock = new ReentrantLock();
4452    private String _portalWebDir;
4453    private Set<String> _portletAddDefaultResourceCheckWhitelist;
4454    private Set<String> _portletAddDefaultResourceCheckWhitelistActions;
4455    private Set<String> _reservedParams;
4456    private String[] _sortedSystemCommunityRoles;
4457    private String[] _sortedSystemGroups;
4458    private String[] _sortedSystemOrganizationRoles;
4459    private String[] _sortedSystemRoles;
4460
4461}