1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.util;
24  
25  import com.liferay.portal.NoSuchLayoutException;
26  import com.liferay.portal.NoSuchUserException;
27  import com.liferay.portal.PortalException;
28  import com.liferay.portal.SystemException;
29  import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
30  import com.liferay.portal.kernel.configuration.Filter;
31  import com.liferay.portal.kernel.language.LanguageUtil;
32  import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
33  import com.liferay.portal.kernel.portlet.LiferayPortletMode;
34  import com.liferay.portal.kernel.servlet.HttpMethods;
35  import com.liferay.portal.kernel.servlet.SessionErrors;
36  import com.liferay.portal.kernel.servlet.StringServletResponse;
37  import com.liferay.portal.kernel.upload.UploadPortletRequest;
38  import com.liferay.portal.kernel.upload.UploadServletRequest;
39  import com.liferay.portal.kernel.util.ArrayUtil;
40  import com.liferay.portal.kernel.util.CalendarFactoryUtil;
41  import com.liferay.portal.kernel.util.CharPool;
42  import com.liferay.portal.kernel.util.ContentTypes;
43  import com.liferay.portal.kernel.util.GetterUtil;
44  import com.liferay.portal.kernel.util.Http;
45  import com.liferay.portal.kernel.util.HttpUtil;
46  import com.liferay.portal.kernel.util.InstancePool;
47  import com.liferay.portal.kernel.util.JavaConstants;
48  import com.liferay.portal.kernel.util.LocaleUtil;
49  import com.liferay.portal.kernel.util.ParamUtil;
50  import com.liferay.portal.kernel.util.StringComparator;
51  import com.liferay.portal.kernel.util.StringPool;
52  import com.liferay.portal.kernel.util.StringUtil;
53  import com.liferay.portal.kernel.util.UnicodeProperties;
54  import com.liferay.portal.kernel.util.Validator;
55  import com.liferay.portal.model.ClassName;
56  import com.liferay.portal.model.Company;
57  import com.liferay.portal.model.Group;
58  import com.liferay.portal.model.Layout;
59  import com.liferay.portal.model.LayoutConstants;
60  import com.liferay.portal.model.LayoutSet;
61  import com.liferay.portal.model.LayoutTypePortlet;
62  import com.liferay.portal.model.Organization;
63  import com.liferay.portal.model.Portlet;
64  import com.liferay.portal.model.PortletApp;
65  import com.liferay.portal.model.User;
66  import com.liferay.portal.model.UserGroup;
67  import com.liferay.portal.model.impl.GroupImpl;
68  import com.liferay.portal.model.impl.RoleImpl;
69  import com.liferay.portal.plugin.PluginPackageUtil;
70  import com.liferay.portal.security.auth.PrincipalException;
71  import com.liferay.portal.security.permission.ActionKeys;
72  import com.liferay.portal.security.permission.PermissionChecker;
73  import com.liferay.portal.security.permission.PermissionCheckerFactory;
74  import com.liferay.portal.service.ClassNameServiceUtil;
75  import com.liferay.portal.service.CompanyLocalServiceUtil;
76  import com.liferay.portal.service.GroupLocalServiceUtil;
77  import com.liferay.portal.service.LayoutLocalServiceUtil;
78  import com.liferay.portal.service.PortletLocalServiceUtil;
79  import com.liferay.portal.service.UserLocalServiceUtil;
80  import com.liferay.portal.service.UserServiceUtil;
81  import com.liferay.portal.service.permission.UserPermissionUtil;
82  import com.liferay.portal.theme.ThemeDisplay;
83  import com.liferay.portal.tools.sql.DBUtil;
84  import com.liferay.portal.upload.UploadPortletRequestImpl;
85  import com.liferay.portal.upload.UploadServletRequestImpl;
86  import com.liferay.portlet.ActionRequestImpl;
87  import com.liferay.portlet.ActionResponseImpl;
88  import com.liferay.portlet.PortletBag;
89  import com.liferay.portlet.PortletBagPool;
90  import com.liferay.portlet.PortletConfigFactory;
91  import com.liferay.portlet.PortletConfigImpl;
92  import com.liferay.portlet.PortletPreferencesImpl;
93  import com.liferay.portlet.PortletPreferencesWrapper;
94  import com.liferay.portlet.PortletRequestImpl;
95  import com.liferay.portlet.PortletResponseImpl;
96  import com.liferay.portlet.PortletURLImpl;
97  import com.liferay.portlet.RenderRequestImpl;
98  import com.liferay.portlet.RenderResponseImpl;
99  import com.liferay.portlet.UserAttributes;
100 import com.liferay.portlet.blogs.model.BlogsEntry;
101 import com.liferay.portlet.bookmarks.model.BookmarksEntry;
102 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
103 import com.liferay.portlet.imagegallery.model.IGImage;
104 import com.liferay.portlet.messageboards.model.MBMessage;
105 import com.liferay.portlet.social.util.FacebookUtil;
106 import com.liferay.portlet.wiki.model.WikiPage;
107 import com.liferay.util.Encryptor;
108 import com.liferay.util.JS;
109 import com.liferay.util.servlet.DynamicServletRequest;
110 
111 import java.io.IOException;
112 
113 import java.net.InetAddress;
114 import java.net.URI;
115 import java.net.URISyntaxException;
116 import java.net.URL;
117 import java.net.UnknownHostException;
118 
119 import java.rmi.RemoteException;
120 
121 import java.util.Arrays;
122 import java.util.Calendar;
123 import java.util.Date;
124 import java.util.Enumeration;
125 import java.util.HashMap;
126 import java.util.HashSet;
127 import java.util.Iterator;
128 import java.util.List;
129 import java.util.Locale;
130 import java.util.Map;
131 import java.util.Properties;
132 import java.util.ResourceBundle;
133 import java.util.Set;
134 import java.util.TimeZone;
135 import java.util.concurrent.ConcurrentHashMap;
136 
137 import javax.portlet.ActionRequest;
138 import javax.portlet.ActionResponse;
139 import javax.portlet.PortletConfig;
140 import javax.portlet.PortletMode;
141 import javax.portlet.PortletPreferences;
142 import javax.portlet.PortletRequest;
143 import javax.portlet.PortletResponse;
144 import javax.portlet.PortletURL;
145 import javax.portlet.PreferencesValidator;
146 import javax.portlet.RenderRequest;
147 import javax.portlet.ValidatorException;
148 import javax.portlet.WindowState;
149 import javax.portlet.filter.PortletRequestWrapper;
150 import javax.portlet.filter.PortletResponseWrapper;
151 
152 import javax.servlet.RequestDispatcher;
153 import javax.servlet.ServletContext;
154 import javax.servlet.ServletException;
155 import javax.servlet.http.HttpServletRequest;
156 import javax.servlet.http.HttpServletRequestWrapper;
157 import javax.servlet.http.HttpServletResponse;
158 import javax.servlet.http.HttpSession;
159 
160 import org.apache.commons.logging.Log;
161 import org.apache.commons.logging.LogFactory;
162 import org.apache.struts.Globals;
163 
164 /**
165  * <a href="PortalImpl.java.html"><b><i>View Source</i></b></a>
166  *
167  * @author Brian Wing Shun Chan
168  * @author Brian Myunghun Kim
169  * @author Jorge Ferrer
170  *
171  */
172 public class PortalImpl implements Portal {
173 
174     public PortalImpl() {
175 
176         // Computer name
177 
178         _computerName = System.getProperty("env.COMPUTERNAME");
179 
180         if (Validator.isNull(_computerName)) {
181             _computerName = System.getProperty("env.HOST");
182         }
183 
184         if (Validator.isNull(_computerName)) {
185             _computerName = System.getProperty("env.HOSTNAME");
186         }
187 
188         if (Validator.isNull(_computerName)) {
189             try {
190                 _computerName = InetAddress.getLocalHost().getHostName();
191             }
192             catch (UnknownHostException uhe) {
193             }
194         }
195 
196         try {
197             _computerAddress = InetAddress.getByName(
198                 _computerName).getHostAddress();
199         }
200         catch (UnknownHostException uhe) {
201         }
202 
203         if (Validator.isNull(_computerAddress)) {
204             try {
205                 _computerAddress = InetAddress.getLocalHost().getHostAddress();
206             }
207             catch (UnknownHostException uhe) {
208             }
209         }
210 
211         // Portal lib directory
212 
213         ClassLoader classLoader = getClass().getClassLoader();
214 
215         URL url = classLoader.getResource(
216             "com/liferay/portal/util/PortalImpl.class");
217 
218         String file = null;
219 
220         try {
221             file = new URI(url.getPath()).getPath();
222         }
223         catch (URISyntaxException urise) {
224             file = url.getFile();
225         }
226 
227         if (_log.isInfoEnabled()) {
228             _log.info("Portal lib url " + file);
229         }
230 
231         int pos = file.indexOf("/com/liferay/portal/util/");
232 
233         _portalLibDir = file.substring(0, pos + 1);
234 
235         if (_portalLibDir.endsWith("/WEB-INF/classes/")) {
236             _portalLibDir = _portalLibDir.substring(
237                 0, _portalLibDir.length() - 8) + "lib/";
238         }
239         else {
240             pos = _portalLibDir.indexOf("/WEB-INF/lib/");
241 
242             if (pos != -1) {
243                 _portalLibDir =
244                     _portalLibDir.substring(0, pos) + "/WEB-INF/lib/";
245             }
246         }
247 
248         if (_portalLibDir.startsWith("file:/")) {
249             _portalLibDir = _portalLibDir.substring(5, _portalLibDir.length());
250         }
251 
252         String portalLibDir = System.getProperty("liferay.lib.portal.dir");
253 
254         if (portalLibDir != null) {
255             if (!portalLibDir.endsWith("/")) {
256                 portalLibDir += "/";
257             }
258 
259             _portalLibDir = portalLibDir;
260         }
261 
262         if (_log.isInfoEnabled()) {
263             _log.info("Portal lib directory " + _portalLibDir);
264         }
265 
266         // CDN host
267 
268         _cdnHost = PropsUtil.get(PropsKeys.CDN_HOST);
269 
270         // Paths
271 
272         _pathContext = PropsUtil.get(PropsKeys.PORTAL_CTX);
273 
274         if (_pathContext.equals(StringPool.SLASH)) {
275             _pathContext = StringPool.BLANK;
276         }
277 
278         _pathFriendlyURLPrivateGroup =
279             _pathContext +
280                 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
281         _pathFriendlyURLPrivateUser =
282             _pathContext +
283                 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
284         _pathFriendlyURLPublic =
285             _pathContext +
286                 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
287         _pathImage = _cdnHost + _pathContext + PATH_IMAGE;
288         _pathMain = _pathContext + PATH_MAIN;
289 
290         // Groups
291 
292         String customSystemGroups[] =
293             PropsUtil.getArray(PropsKeys.SYSTEM_GROUPS);
294 
295         if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
296             _allSystemGroups = GroupImpl.SYSTEM_GROUPS;
297         }
298         else {
299             _allSystemGroups = ArrayUtil.append(
300                 GroupImpl.SYSTEM_GROUPS, customSystemGroups);
301         }
302 
303         _sortedSystemGroups = new String[_allSystemGroups.length];
304 
305         System.arraycopy(
306             _allSystemGroups, 0, _sortedSystemGroups, 0,
307             _allSystemGroups.length);
308 
309         Arrays.sort(_sortedSystemGroups, new StringComparator());
310 
311         // Regular roles
312 
313         String customSystemRoles[] = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
314 
315         if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
316             _allSystemRoles = RoleImpl.SYSTEM_ROLES;
317         }
318         else {
319             _allSystemRoles = ArrayUtil.append(
320                 RoleImpl.SYSTEM_ROLES, customSystemRoles);
321         }
322 
323         _sortedSystemRoles = new String[_allSystemRoles.length];
324 
325         System.arraycopy(
326             _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
327 
328         Arrays.sort(_sortedSystemRoles, new StringComparator());
329 
330         // Community roles
331 
332         String customSystemCommunityRoles[] =
333             PropsUtil.getArray(PropsKeys.SYSTEM_COMMUNITY_ROLES);
334 
335         if ((customSystemCommunityRoles == null) ||
336             (customSystemCommunityRoles.length == 0)) {
337 
338             _allSystemCommunityRoles = RoleImpl.SYSTEM_COMMUNITY_ROLES;
339         }
340         else {
341             _allSystemCommunityRoles = ArrayUtil.append(
342                 RoleImpl.SYSTEM_COMMUNITY_ROLES, customSystemCommunityRoles);
343         }
344 
345         _sortedSystemCommunityRoles =
346             new String[_allSystemCommunityRoles.length];
347 
348         System.arraycopy(
349             _allSystemCommunityRoles, 0, _sortedSystemCommunityRoles, 0,
350                 _allSystemCommunityRoles.length);
351 
352         Arrays.sort(_sortedSystemCommunityRoles, new StringComparator());
353 
354         // Organization Roles
355 
356         String customSystemOrganizationRoles[] =
357             PropsUtil.getArray(PropsKeys.SYSTEM_ORGANIZATION_ROLES);
358 
359         if ((customSystemOrganizationRoles == null) ||
360             (customSystemOrganizationRoles.length == 0)) {
361 
362             _allSystemOrganizationRoles = RoleImpl.SYSTEM_ORGANIZATION_ROLES;
363         }
364         else {
365             _allSystemOrganizationRoles = ArrayUtil.append(
366                 RoleImpl.SYSTEM_ORGANIZATION_ROLES,
367                 customSystemOrganizationRoles);
368         }
369 
370         _sortedSystemOrganizationRoles =
371             new String[_allSystemOrganizationRoles.length];
372 
373         System.arraycopy(
374             _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
375                 _allSystemOrganizationRoles.length);
376 
377         Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
378 
379         // Reserved parameter names
380 
381         _reservedParams = new HashSet<String>();
382 
383         _reservedParams.add("p_l_id");
384         _reservedParams.add("p_l_reset");
385         _reservedParams.add("p_p_id");
386         _reservedParams.add("p_p_lifecycle");
387         _reservedParams.add("p_p_url_type");
388         _reservedParams.add("p_p_state");
389         _reservedParams.add("p_p_mode");
390         _reservedParams.add("p_p_resource_id");
391         _reservedParams.add("p_p_cacheability");
392         _reservedParams.add("p_p_width");
393         _reservedParams.add("p_p_col_id");
394         _reservedParams.add("p_p_col_pos");
395         _reservedParams.add("p_p_col_count");
396         _reservedParams.add("p_p_static");
397         _reservedParams.add("saveLastPath");
398     }
399 
400     public void clearRequestParameters(RenderRequest renderRequest) {
401 
402         // Clear the render parameters if they were set during processAction
403 
404         ThemeDisplay themeDisplay = (ThemeDisplay)renderRequest.getAttribute(
405             WebKeys.THEME_DISPLAY);
406 
407         if (themeDisplay.isLifecycleAction()) {
408             ((RenderRequestImpl)renderRequest).getRenderParameters().clear();
409         }
410     }
411 
412     public void copyRequestParameters(
413         ActionRequest actionRequest, ActionResponse actionResponse) {
414 
415         try {
416             ActionResponseImpl actionResponseImpl =
417                 (ActionResponseImpl)actionResponse;
418 
419             Map<String, String[]> renderParameters =
420                 actionResponseImpl.getRenderParameterMap();
421 
422             actionResponse.setRenderParameter("p_p_lifecycle", "1");
423 
424             Enumeration<String> enu = actionRequest.getParameterNames();
425 
426             while (enu.hasMoreElements()) {
427                 String param = enu.nextElement();
428                 String[] values = actionRequest.getParameterValues(param);
429 
430                 if (renderParameters.get(
431                         actionResponseImpl.getNamespace() + param) == null) {
432 
433                     actionResponse.setRenderParameter(param, values);
434                 }
435             }
436         }
437         catch (IllegalStateException ise) {
438 
439             // This should only happen if the developer called
440             // sendRedirect of javax.portlet.ActionResponse
441 
442         }
443     }
444 
445     public String getCDNHost() {
446         return _cdnHost;
447     }
448 
449     public String getClassName(long classNameId) {
450         try {
451             ClassName className = ClassNameServiceUtil.getClassName(
452                 classNameId);
453 
454             return className.getValue();
455         }
456         catch (Exception e) {
457             throw new RuntimeException(
458                 "Unable to get class name from id " + classNameId);
459         }
460     }
461 
462     public long getClassNameId(Class<?> classObj) {
463         return getClassNameId(classObj.getName());
464     }
465 
466     public long getClassNameId(String value) {
467         try {
468             ClassName className = ClassNameServiceUtil.getClassName(value);
469 
470             return className.getClassNameId();
471         }
472         catch (Exception e) {
473             throw new RuntimeException(
474                 "Unable to get class name from value " + value, e);
475         }
476     }
477 
478     public String getClassNamePortletId(String className) {
479         String portletId = StringPool.BLANK;
480 
481         if (className.startsWith("com.liferay.portlet.blogs")) {
482             portletId = PortletKeys.BLOGS;
483         }
484         else if (className.startsWith("com.liferay.portlet.bookmarks")) {
485             portletId = PortletKeys.BOOKMARKS;
486         }
487         else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
488             portletId = PortletKeys.DOCUMENT_LIBRARY;
489         }
490         else if (className.startsWith("com.liferay.portlet.imagegallery")) {
491             portletId = PortletKeys.IMAGE_GALLERY;
492         }
493         else if (className.startsWith("com.liferay.portlet.journal")) {
494             portletId = PortletKeys.JOURNAL;
495         }
496         else if (className.startsWith("com.liferay.portlet.messageboards")) {
497             portletId = PortletKeys.MESSAGE_BOARDS;
498         }
499         else if (className.startsWith("com.liferay.portlet.wiki")) {
500             portletId = PortletKeys.WIKI;
501         }
502 
503         return portletId;
504     }
505 
506     public String getCommunityLoginURL(ThemeDisplay themeDisplay)
507         throws PortalException, SystemException {
508 
509         if (Validator.isNull(PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
510             return null;
511         }
512 
513         for (Layout layout : themeDisplay.getLayouts()) {
514             if (layout.getFriendlyURL().equals(
515                     PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
516 
517                 if (themeDisplay.getLayout() != null) {
518                     String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
519                         themeDisplay.getLayout().getLayoutSet(), themeDisplay);
520 
521                     return layoutSetFriendlyURL +
522                         PropsValues.AUTH_LOGIN_COMMUNITY_URL;
523                 }
524 
525                 break;
526             }
527         }
528 
529         return null;
530     }
531 
532     public Company getCompany(HttpServletRequest request)
533         throws PortalException, SystemException {
534 
535         long companyId = getCompanyId(request);
536 
537         if (companyId <= 0) {
538             return null;
539         }
540 
541         Company company = (Company)request.getAttribute(WebKeys.COMPANY);
542 
543         if (company == null) {
544             company = CompanyLocalServiceUtil.getCompanyById(companyId);
545 
546             request.setAttribute(WebKeys.COMPANY, company);
547         }
548 
549         return company;
550     }
551 
552     public Company getCompany(ActionRequest actionRequest)
553         throws PortalException, SystemException {
554 
555         return getCompany(getHttpServletRequest(actionRequest));
556     }
557 
558     public Company getCompany(RenderRequest renderRequest)
559         throws PortalException, SystemException {
560 
561         return getCompany(getHttpServletRequest(renderRequest));
562     }
563 
564     public long getCompanyId(HttpServletRequest request) {
565         return PortalInstances.getCompanyId(request);
566     }
567 
568     public long getCompanyId(ActionRequest actionRequest) {
569         return getCompanyId(getHttpServletRequest(actionRequest));
570     }
571 
572     public long getCompanyId(PortletRequest portletRequest) {
573         long companyId = 0;
574 
575         if (portletRequest instanceof ActionRequest) {
576             companyId = getCompanyId((ActionRequest)portletRequest);
577         }
578         else {
579             companyId = getCompanyId((RenderRequest)portletRequest);
580         }
581 
582         return companyId;
583     }
584 
585     public long getCompanyId(RenderRequest renderRequest) {
586         return getCompanyId(getHttpServletRequest(renderRequest));
587     }
588 
589     public long getCompanyIdByWebId(ServletContext servletContext) {
590         String webId = GetterUtil.getString(
591             servletContext.getInitParameter("company_web_id"));
592 
593         return getCompanyIdByWebId(webId);
594     }
595 
596     public long getCompanyIdByWebId(String webId) {
597         long companyId = 0;
598 
599         try {
600             Company company = CompanyLocalServiceUtil.getCompanyByWebId(webId);
601 
602             companyId = company.getCompanyId();
603         }
604         catch (Exception e) {
605             _log.error(e.getMessage());
606         }
607 
608         return companyId;
609     }
610 
611     public long[] getCompanyIds() {
612         return PortalInstances.getCompanyIds();
613     }
614 
615     public String getComputerAddress() {
616         return _computerAddress;
617     }
618 
619     public String getComputerName() {
620         return _computerName;
621     }
622 
623     public String getCurrentURL(HttpServletRequest request) {
624         String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
625 
626         if (currentURL == null) {
627             currentURL = ParamUtil.getString(request, "currentURL");
628 
629             if (Validator.isNull(currentURL)) {
630                 if (true) {
631                     currentURL = HttpUtil.getCompleteURL(request);
632                 }
633                 else {
634 
635                     // Do we need to trim redirects?
636 
637                     currentURL = _getCurrentURL(request);
638                 }
639 
640                 if ((Validator.isNotNull(currentURL)) &&
641                     (currentURL.indexOf("j_security_check") == -1)) {
642 
643                     currentURL = currentURL.substring(
644                         currentURL.indexOf("://") + 3, currentURL.length());
645 
646                     currentURL = currentURL.substring(
647                         currentURL.indexOf("/"), currentURL.length());
648                 }
649 
650                 if (Validator.isNotNull(currentURL) &&
651                     FacebookUtil.isFacebook(currentURL)) {
652 
653                     String[] facebookData = FacebookUtil.getFacebookData(
654                         request);
655 
656                     currentURL =
657                         FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
658                             facebookData[2];
659                 }
660             }
661 
662             if (Validator.isNull(currentURL)) {
663                 currentURL = getPathMain();
664             }
665 
666             request.setAttribute(WebKeys.CURRENT_URL, currentURL);
667         }
668 
669         return currentURL;
670     }
671 
672     public String getCurrentURL(PortletRequest portletRequest) {
673         return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
674     }
675 
676     public String getCustomSQLFunctionIsNotNull() {
677         return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
678     }
679 
680     public String getCustomSQLFunctionIsNull() {
681         return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
682     }
683 
684     public Date getDate(int month, int day, int year, PortalException pe)
685         throws PortalException {
686 
687         return getDate(month, day, year, null, pe);
688     }
689 
690     public Date getDate(
691             int month, int day, int year, TimeZone timeZone, PortalException pe)
692         throws PortalException {
693 
694         return getDate(month, day, year, -1, -1, timeZone, pe);
695     }
696 
697     public Date getDate(
698             int month, int day, int year, int hour, int min, PortalException pe)
699         throws PortalException {
700 
701         return getDate(month, day, year, hour, min, null, pe);
702     }
703 
704     public Date getDate(
705             int month, int day, int year, int hour, int min, TimeZone timeZone,
706             PortalException pe)
707         throws PortalException {
708 
709         if (!Validator.isGregorianDate(month, day, year)) {
710             throw pe;
711         }
712         else {
713             Calendar cal = null;
714 
715             if (timeZone == null) {
716                 cal = CalendarFactoryUtil.getCalendar();
717             }
718             else {
719                 cal = CalendarFactoryUtil.getCalendar(timeZone);
720             }
721 
722             if ((hour == -1) || (min == -1)) {
723                 cal.set(year, month, day, 0, 0, 0);
724             }
725             else {
726                 cal.set(year, month, day, hour, min, 0);
727             }
728 
729             cal.set(Calendar.MILLISECOND, 0);
730 
731             Date date = cal.getTime();
732 
733             /*if (timeZone != null &&
734                 cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
735 
736                 throw pe;
737             }*/
738 
739             return date;
740         }
741     }
742 
743     public String getHost(HttpServletRequest request) {
744         request = getOriginalServletRequest(request);
745 
746         String host = request.getHeader("Host");
747 
748         if (host != null) {
749             host = host.trim().toLowerCase();
750 
751             int pos = host.indexOf(':');
752 
753             if (pos >= 0) {
754                 host = host.substring(0, pos);
755             }
756         }
757         else {
758             host = null;
759         }
760 
761         return host;
762     }
763 
764     public String getHost(ActionRequest actionRequest) {
765         return getHost(getHttpServletRequest(actionRequest));
766     }
767 
768     public String getHost(RenderRequest renderRequest) {
769         return getHost(getHttpServletRequest(renderRequest));
770     }
771 
772     public HttpServletRequest getHttpServletRequest(
773         PortletRequest portletRequest) {
774 
775         if (portletRequest instanceof PortletRequestImpl) {
776             PortletRequestImpl portletRequestImpl =
777                 (PortletRequestImpl)portletRequest;
778 
779             return portletRequestImpl.getHttpServletRequest();
780         }
781         else if (portletRequest instanceof PortletRequestWrapper) {
782             PortletRequestWrapper portletRequestWrapper =
783                 (PortletRequestWrapper)portletRequest;
784 
785             return getHttpServletRequest(portletRequestWrapper.getRequest());
786         }
787         else {
788             throw new RuntimeException(
789                 "Unable to get the HTTP servlet request from " +
790                     portletRequest.getClass().getName());
791         }
792     }
793 
794     public HttpServletResponse getHttpServletResponse(
795         PortletResponse portletResponse) {
796 
797         if (portletResponse instanceof ActionResponseImpl) {
798             ActionResponseImpl actionResponseImpl =
799                 (ActionResponseImpl)portletResponse;
800 
801             return actionResponseImpl.getHttpServletResponse();
802         }
803         else if (portletResponse instanceof RenderResponseImpl) {
804             RenderResponseImpl renderResponseImpl =
805                 (RenderResponseImpl)portletResponse;
806 
807             return renderResponseImpl.getHttpServletResponse();
808         }
809         else if (portletResponse instanceof PortletResponseWrapper) {
810             PortletResponseWrapper portletResponseWrapper =
811                 (PortletResponseWrapper)portletResponse;
812 
813             return getHttpServletResponse(portletResponseWrapper.getResponse());
814         }
815         else {
816             PortletResponseImpl portletResponseImpl =
817                 PortletResponseImpl.getPortletResponseImpl(portletResponse);
818 
819             return portletResponseImpl.getHttpServletResponse();
820         }
821     }
822 
823     public String getLayoutEditPage(Layout layout) {
824         return PropsUtil.get(
825             PropsKeys.LAYOUT_EDIT_PAGE, new Filter(layout.getType()));
826     }
827 
828     public String getLayoutViewPage(Layout layout) {
829         return PropsUtil.get(
830             PropsKeys.LAYOUT_VIEW_PAGE, new Filter(layout.getType()));
831     }
832 
833     public String getLayoutURL(ThemeDisplay themeDisplay) {
834         return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
835     }
836 
837     public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay) {
838         return getLayoutURL(layout, themeDisplay, true);
839     }
840 
841     public String getLayoutURL(
842         Layout layout, ThemeDisplay themeDisplay, boolean doAsUser) {
843 
844         if (layout == null) {
845             return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
846         }
847 
848         if (!layout.getType().equals(LayoutConstants.TYPE_URL)) {
849             String layoutFriendlyURL = getLayoutFriendlyURL(
850                 layout, themeDisplay);
851 
852             if (Validator.isNotNull(layoutFriendlyURL)) {
853                 if (doAsUser &&
854                     Validator.isNotNull(themeDisplay.getDoAsUserId())) {
855 
856                     layoutFriendlyURL = HttpUtil.addParameter(
857                         layoutFriendlyURL, "doAsUserId",
858                         themeDisplay.getDoAsUserId());
859                 }
860 
861                 return layoutFriendlyURL;
862             }
863         }
864 
865         String layoutURL = getLayoutActualURL(layout);
866 
867         if (doAsUser && Validator.isNotNull(themeDisplay.getDoAsUserId())) {
868             layoutURL = HttpUtil.addParameter(
869                 layoutURL, "doAsUserId", themeDisplay.getDoAsUserId());
870         }
871 
872         return layoutURL;
873     }
874 
875     public String getLayoutActualURL(Layout layout) {
876         return getLayoutActualURL(layout, getPathMain());
877     }
878 
879     public String getLayoutActualURL(Layout layout, String mainPath) {
880         Map<String, String> variables = new HashMap<String, String>();
881 
882         variables.put("liferay:mainPath", mainPath);
883         variables.put("liferay:plid", String.valueOf(layout.getPlid()));
884 
885         UnicodeProperties typeSettingsProperties =
886             layout.getLayoutType().getTypeSettingsProperties();
887 
888         Iterator<Map.Entry<String, String>> itr =
889             typeSettingsProperties.entrySet().iterator();
890 
891         while (itr.hasNext()) {
892             Map.Entry<String, String> entry = itr.next();
893 
894             String key = entry.getKey();
895             String value = entry.getValue();
896 
897             variables.put(key, value);
898         }
899 
900         String href = PropsUtil.get(
901             PropsKeys.LAYOUT_URL, new Filter(layout.getType(), variables));
902 
903         return href;
904     }
905 
906     public String getLayoutActualURL(
907             long groupId, boolean privateLayout, String mainPath,
908             String friendlyURL)
909         throws PortalException, SystemException {
910 
911         return getLayoutActualURL(
912             groupId, privateLayout, mainPath, friendlyURL, null);
913     }
914 
915     public String getLayoutActualURL(
916             long groupId, boolean privateLayout, String mainPath,
917             String friendlyURL, Map<String, String[]> params)
918         throws PortalException, SystemException {
919 
920         Layout layout = null;
921         String queryString = StringPool.BLANK;
922 
923         if (Validator.isNull(friendlyURL)) {
924             List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
925                 groupId, privateLayout,
926                 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
927 
928             if (layouts.size() > 0) {
929                 layout = layouts.get(0);
930             }
931             else {
932                 throw new NoSuchLayoutException(
933                     "{groupId=" + groupId + ",privateLayout=" + privateLayout +
934                         "} does not have any layouts");
935             }
936         }
937         else {
938             Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
939                 groupId, privateLayout, friendlyURL, params);
940 
941             layout = (Layout)friendlyURLMapper[0];
942             queryString = (String)friendlyURLMapper[1];
943         }
944 
945         String layoutActualURL = getLayoutActualURL(layout, mainPath);
946 
947         if (Validator.isNotNull(queryString)) {
948             layoutActualURL = layoutActualURL + queryString;
949         }
950 
951         return layoutActualURL;
952     }
953 
954     public String getLayoutFriendlyURL(
955         Layout layout, ThemeDisplay themeDisplay) {
956 
957         if (!isLayoutFriendliable(layout)) {
958             return null;
959         }
960 
961         String layoutFriendlyURL = layout.getFriendlyURL();
962 
963         LayoutSet layoutSet = layout.getLayoutSet();
964 
965         if (Validator.isNotNull(layoutSet.getVirtualHost())) {
966             String portalURL = getPortalURL(
967                 layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
968                 themeDisplay.isSecure());
969 
970             // Use the layout set's virtual host setting only if the layout set
971             // is already used for the current request
972 
973             long curLayoutSetId =
974                 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
975 
976             if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
977                     (portalURL.startsWith(themeDisplay.getURLPortal()))) {
978 
979                 return portalURL + getPathContext() + layoutFriendlyURL;
980             }
981         }
982 
983         Group group = layout.getGroup();
984 
985         String friendlyURL = null;
986 
987         if (layout.isPrivateLayout()) {
988             if (group.isUser()) {
989                 friendlyURL = getPathFriendlyURLPrivateUser();
990             }
991             else {
992                 friendlyURL = getPathFriendlyURLPrivateGroup();
993             }
994         }
995         else {
996             friendlyURL = getPathFriendlyURLPublic();
997         }
998 
999         if (themeDisplay.isWidget()) {
1000            friendlyURL = "/widget" + friendlyURL;
1001        }
1002
1003        if (themeDisplay.isI18n()) {
1004            friendlyURL =
1005                StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1006                    friendlyURL;
1007        }
1008
1009        return friendlyURL + group.getFriendlyURL() + layoutFriendlyURL;
1010    }
1011
1012    public String getLayoutSetFriendlyURL(
1013            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1014        throws PortalException, SystemException {
1015
1016        if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1017            String portalURL = getPortalURL(
1018                layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1019                themeDisplay.isSecure());
1020
1021            // Use the layout set's virtual host setting only if the layout set
1022            // is already used for the current request
1023
1024            long curLayoutSetId =
1025                themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1026
1027            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1028                (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1029
1030                return portalURL + getPathContext();
1031            }
1032        }
1033
1034        Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1035
1036        String friendlyURL = null;
1037
1038        if (layoutSet.isPrivateLayout()) {
1039            if (group.isUser()) {
1040                friendlyURL = getPathFriendlyURLPrivateUser();
1041            }
1042            else {
1043                friendlyURL = getPathFriendlyURLPrivateGroup();
1044            }
1045        }
1046        else {
1047            friendlyURL = getPathFriendlyURLPublic();
1048        }
1049
1050        return friendlyURL + group.getFriendlyURL();
1051    }
1052
1053    public String getLayoutTarget(Layout layout) {
1054        UnicodeProperties typeSettingsProps =
1055            layout.getTypeSettingsProperties();
1056
1057        String target = typeSettingsProps.getProperty("target");
1058
1059        if (Validator.isNull(target)) {
1060            target = StringPool.BLANK;
1061        }
1062        else {
1063            target = "target=\"" + target + "\"";
1064        }
1065
1066        return target;
1067    }
1068
1069    public String getJsSafePortletId(String portletId) {
1070        return JS.getSafeName(portletId);
1071    }
1072
1073    public Locale getLocale(HttpServletRequest request) {
1074        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1075            WebKeys.THEME_DISPLAY);
1076
1077        if (themeDisplay != null) {
1078            return themeDisplay.getLocale();
1079        }
1080        else {
1081            HttpSession session = request.getSession();
1082
1083            return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1084        }
1085    }
1086
1087    public Locale getLocale(RenderRequest renderRequest) {
1088        return getLocale(getHttpServletRequest(renderRequest));
1089    }
1090
1091    public HttpServletRequest getOriginalServletRequest(
1092        HttpServletRequest request) {
1093
1094        HttpServletRequest originalRequest = request;
1095
1096        while (originalRequest.getClass().getName().startsWith(
1097                    "com.liferay.")) {
1098
1099            // Get original request so that portlets inside portlets render
1100            // properly
1101
1102            originalRequest = (HttpServletRequest)
1103                ((HttpServletRequestWrapper)originalRequest).getRequest();
1104        }
1105
1106        return originalRequest;
1107    }
1108
1109    public String getPathContext() {
1110        return _pathContext;
1111    }
1112
1113    public String getPathFriendlyURLPrivateGroup() {
1114        return _pathFriendlyURLPrivateGroup;
1115    }
1116
1117    public String getPathFriendlyURLPrivateUser() {
1118        return _pathFriendlyURLPrivateUser;
1119    }
1120
1121    public String getPathFriendlyURLPublic() {
1122        return _pathFriendlyURLPublic;
1123    }
1124
1125    public String getPathImage() {
1126        return _pathImage;
1127    }
1128
1129    public String getPathMain() {
1130        return _pathMain;
1131    }
1132
1133    public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1134        if (Validator.isNull(friendlyURL)) {
1135            return LayoutConstants.DEFAULT_PLID;
1136        }
1137
1138        String[] urlParts = friendlyURL.split("\\/", 4);
1139
1140        if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1141            (urlParts.length != 4)) {
1142
1143            return LayoutConstants.DEFAULT_PLID;
1144        }
1145
1146        boolean privateLayout = true;
1147
1148        String urlPrefix = StringPool.SLASH + urlParts[1];
1149
1150        if (getPathFriendlyURLPublic().equals(urlPrefix)) {
1151            privateLayout = false;
1152        }
1153        else if (getPathFriendlyURLPrivateGroup().equals(urlPrefix) ||
1154                 getPathFriendlyURLPrivateUser().equals(urlPrefix)) {
1155
1156            privateLayout = true;
1157        }
1158        else {
1159            return LayoutConstants.DEFAULT_PLID;
1160        }
1161
1162        Group group = null;
1163
1164        try {
1165            group = GroupLocalServiceUtil.getFriendlyURLGroup(
1166                companyId, StringPool.SLASH + urlParts[2]);
1167        }
1168        catch (Exception e) {
1169        }
1170
1171        if (group != null) {
1172            Layout layout = null;
1173
1174            try {
1175                layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1176                    group.getGroupId(), privateLayout,
1177                    StringPool.SLASH + urlParts[3]);
1178
1179                return layout.getPlid();
1180            }
1181            catch (Exception e) {
1182            }
1183        }
1184
1185        return LayoutConstants.DEFAULT_PLID;
1186    }
1187
1188    public long getPlidFromPortletId(
1189        long groupId, boolean privateLayout, String portletId) {
1190
1191        long plid = LayoutConstants.DEFAULT_PLID;
1192
1193        StringBuilder sb = new StringBuilder();
1194
1195        sb.append(groupId);
1196        sb.append(StringPool.SPACE);
1197        sb.append(privateLayout);
1198        sb.append(StringPool.SPACE);
1199        sb.append(portletId);
1200
1201        String key = sb.toString();
1202
1203        Long plidObj = _plidToPortletIdCache.get(key);
1204
1205        if (plidObj == null) {
1206            plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1207
1208            if (plid != LayoutConstants.DEFAULT_PLID) {
1209                _plidToPortletIdCache.put(key, plid);
1210            }
1211        }
1212        else {
1213            plid = plidObj.longValue();
1214
1215            boolean validPlid = false;
1216
1217            try {
1218                Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1219
1220                LayoutTypePortlet layoutTypePortlet =
1221                    (LayoutTypePortlet)layout.getLayoutType();
1222
1223                if (layoutTypePortlet.hasPortletId(portletId)) {
1224                    validPlid = true;
1225                }
1226            }
1227            catch (Exception e) {
1228            }
1229
1230            if (!validPlid) {
1231                _plidToPortletIdCache.remove(key);
1232
1233                plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1234
1235                if (plid != LayoutConstants.DEFAULT_PLID) {
1236                    _plidToPortletIdCache.put(key, plid);
1237                }
1238            }
1239        }
1240
1241        return plid;
1242    }
1243
1244    public String getPortalLibDir() {
1245        return _portalLibDir;
1246    }
1247
1248    public int getPortalPort() {
1249        return _portalPort.intValue();
1250    }
1251
1252    public Properties getPortalProperties() {
1253        return PropsUtil.getProperties();
1254    }
1255
1256    public String getPortalURL(ThemeDisplay themeDisplay) {
1257        String serverName = themeDisplay.getServerName();
1258
1259        Layout layout = themeDisplay.getLayout();
1260
1261        if (layout != null) {
1262            LayoutSet layoutSet = layout.getLayoutSet();
1263
1264            if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1265                serverName = layoutSet.getVirtualHost();
1266            }
1267        }
1268
1269        return getPortalURL(
1270            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
1271    }
1272
1273    public String getPortalURL(HttpServletRequest request) {
1274        return getPortalURL(request, request.isSecure());
1275    }
1276
1277    public String getPortalURL(HttpServletRequest request, boolean secure) {
1278        return getPortalURL(
1279            request.getServerName(), request.getServerPort(), secure);
1280    }
1281
1282    public String getPortalURL(PortletRequest portletRequest) {
1283        return getPortalURL(portletRequest, portletRequest.isSecure());
1284    }
1285
1286    public String getPortalURL(PortletRequest portletRequest, boolean secure) {
1287        return getPortalURL(
1288            portletRequest.getServerName(), portletRequest.getServerPort(),
1289            secure);
1290    }
1291
1292    public String getPortalURL(
1293        String serverName, int serverPort, boolean secure) {
1294
1295        StringBuilder sb = new StringBuilder();
1296
1297        if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
1298            sb.append(Http.HTTPS_WITH_SLASH);
1299        }
1300        else {
1301            sb.append(Http.HTTP_WITH_SLASH);
1302        }
1303
1304        if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
1305            sb.append(serverName);
1306        }
1307        else {
1308            sb.append(PropsValues.WEB_SERVER_HOST);
1309        }
1310
1311        if (!secure) {
1312            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
1313                if ((serverPort != Http.HTTP_PORT) &&
1314                    (serverPort != Http.HTTPS_PORT)) {
1315
1316                    sb.append(StringPool.COLON);
1317                    sb.append(serverPort);
1318                }
1319            }
1320            else {
1321                if ((PropsValues.WEB_SERVER_HTTP_PORT != serverPort) &&
1322                    (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT)) {
1323
1324                    sb.append(StringPool.COLON);
1325                    sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
1326                }
1327            }
1328        }
1329
1330        if (secure) {
1331            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
1332                if ((serverPort != Http.HTTP_PORT) &&
1333                    (serverPort != Http.HTTPS_PORT)) {
1334
1335                    sb.append(StringPool.COLON);
1336                    sb.append(serverPort);
1337                }
1338            }
1339            else {
1340                if ((PropsValues.WEB_SERVER_HTTPS_PORT != serverPort) &&
1341                    (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT)) {
1342
1343                    sb.append(StringPool.COLON);
1344                    sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
1345                }
1346            }
1347        }
1348
1349        return sb.toString();
1350    }
1351
1352    public Object[] getPortletFriendlyURLMapper(
1353            long groupId, boolean privateLayout, String url)
1354        throws PortalException, SystemException {
1355
1356        return getPortletFriendlyURLMapper(groupId, privateLayout, url, null);
1357    }
1358
1359    public Object[] getPortletFriendlyURLMapper(
1360            long groupId, boolean privateLayout, String url,
1361            Map<String, String[]> params)
1362        throws PortalException, SystemException {
1363
1364        boolean foundFriendlyURLMapper = false;
1365
1366        String friendlyURL = url;
1367        String queryString = StringPool.BLANK;
1368
1369        List<FriendlyURLMapper> friendlyURLMappers =
1370            PortletLocalServiceUtil.getFriendlyURLMappers();
1371
1372        Iterator<FriendlyURLMapper> itr = friendlyURLMappers.iterator();
1373
1374        while (itr.hasNext()) {
1375            FriendlyURLMapper friendlyURLMapper = itr.next();
1376
1377            if (url.endsWith(
1378                    StringPool.SLASH + friendlyURLMapper.getMapping())) {
1379
1380                url += StringPool.SLASH;
1381            }
1382
1383            int pos = -1;
1384
1385            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1386                pos = url.indexOf(
1387                    "/-/" + friendlyURLMapper.getMapping() + StringPool.SLASH);
1388            }
1389            else {
1390                pos = url.indexOf(
1391                    StringPool.SLASH + friendlyURLMapper.getMapping() +
1392                        StringPool.SLASH);
1393            }
1394
1395            if (pos != -1) {
1396                foundFriendlyURLMapper = true;
1397
1398                friendlyURL = url.substring(0, pos);
1399
1400                Map<String, String[]> actualParams = null;
1401
1402                if (params != null) {
1403                    actualParams = new HashMap<String, String[]>(params);
1404                }
1405                else {
1406                    actualParams = new HashMap<String, String[]>();
1407                }
1408
1409                /*Object lifecycle = actualParams.get("p_p_lifecycle");
1410
1411                if ((lifecycle == null) ||
1412                    (((String[])lifecycle).length == 0)) {
1413
1414                    actualParams.put("p_p_lifecycle", "0");
1415                }
1416
1417                Object state = actualParams.get("p_p_state");
1418
1419                if ((state == null) || (((String[])state).length == 0)) {
1420                    actualParams.put(
1421                        "p_p_state", WindowState.MAXIMIZED.toString());
1422                }*/
1423
1424                if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1425                    friendlyURLMapper.populateParams(
1426                        url.substring(pos + 2), actualParams);
1427                }
1428                else {
1429                    friendlyURLMapper.populateParams(
1430                        url.substring(pos), actualParams);
1431                }
1432
1433                queryString =
1434                    StringPool.AMPERSAND +
1435                        HttpUtil.parameterMapToString(actualParams, false);
1436
1437                break;
1438            }
1439        }
1440
1441        if (!foundFriendlyURLMapper) {
1442            int x = url.indexOf("/-/");
1443
1444            if (x != -1) {
1445                int y = url.indexOf(StringPool.SLASH, x + 3);
1446
1447                if (y == -1) {
1448                    y = url.length();
1449                }
1450
1451                String ppid = url.substring(x + 3, y);
1452
1453                if (Validator.isNotNull(ppid)) {
1454                    friendlyURL = url.substring(0, x);
1455
1456                    Map<String, String[]> actualParams = null;
1457
1458                    if (params != null) {
1459                        actualParams = new HashMap<String, String[]>(params);
1460                    }
1461                    else {
1462                        actualParams = new HashMap<String, String[]>();
1463                    }
1464
1465                    actualParams.put("p_p_id", new String[] {ppid});
1466                    actualParams.put("p_p_lifecycle", new String[] {"0"});
1467                    actualParams.put(
1468                        "p_p_state",
1469                        new String[] {WindowState.MAXIMIZED.toString()});
1470                    actualParams.put(
1471                        "p_p_mode", new String[] {PortletMode.VIEW.toString()});
1472
1473                    queryString =
1474                        StringPool.AMPERSAND +
1475                            HttpUtil.parameterMapToString(actualParams, false);
1476                }
1477            }
1478        }
1479
1480        friendlyURL = StringUtil.replace(
1481            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
1482
1483        if (friendlyURL.endsWith(StringPool.SLASH)) {
1484            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
1485        }
1486
1487        Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1488            groupId, privateLayout, friendlyURL);
1489
1490        return new Object[] {layout, queryString};
1491    }
1492
1493    public long getPortletGroupId(long plid) {
1494        Layout layout = null;
1495
1496        try {
1497            layout = LayoutLocalServiceUtil.getLayout(plid);
1498        }
1499        catch (Exception e) {
1500        }
1501
1502        return getPortletGroupId(layout);
1503    }
1504
1505    public long getPortletGroupId(Layout layout) {
1506        if (layout == null) {
1507            return 0;
1508        }
1509        else {
1510            return layout.getGroupId();
1511        }
1512    }
1513
1514    public long getPortletGroupId(HttpServletRequest request) {
1515        Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
1516
1517        return getPortletGroupId(layout);
1518    }
1519
1520    public long getPortletGroupId(ActionRequest actionRequest) {
1521        return getPortletGroupId(getHttpServletRequest(actionRequest));
1522    }
1523
1524    public long getPortletGroupId(RenderRequest renderRequest) {
1525        return getPortletGroupId(getHttpServletRequest(renderRequest));
1526    }
1527
1528    public String getPortletId(HttpServletRequest request) {
1529        PortletConfigImpl configImpl = (PortletConfigImpl)request.getAttribute(
1530            JavaConstants.JAVAX_PORTLET_CONFIG);
1531
1532        return configImpl.getPortletId();
1533    }
1534
1535    public String getPortletId(ActionRequest actionRequest) {
1536        PortletConfigImpl configImpl =
1537            (PortletConfigImpl)actionRequest.getAttribute(
1538                JavaConstants.JAVAX_PORTLET_CONFIG);
1539
1540        return configImpl.getPortletId();
1541    }
1542
1543    public String getPortletId(RenderRequest renderRequest) {
1544        PortletConfigImpl portletConfigImpl =
1545            (PortletConfigImpl)renderRequest.getAttribute(
1546                JavaConstants.JAVAX_PORTLET_CONFIG);
1547
1548        return portletConfigImpl.getPortletId();
1549    }
1550
1551    public String getPortletNamespace(String portletId) {
1552        StringBuilder sb = new StringBuilder();
1553
1554        sb.append(StringPool.UNDERLINE);
1555        sb.append(portletId);
1556        sb.append(StringPool.UNDERLINE);
1557
1558        return sb.toString();
1559    }
1560
1561    public String getPortletTitle(
1562        String portletId, long companyId, String languageId) {
1563
1564        Locale locale = LocaleUtil.fromLanguageId(languageId);
1565
1566        return getPortletTitle(portletId, companyId, locale);
1567    }
1568
1569    public String getPortletTitle(
1570        String portletId, long companyId, Locale locale) {
1571
1572        StringBuilder sb = new StringBuilder();
1573
1574        sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1575        sb.append(StringPool.PERIOD);
1576        sb.append(portletId);
1577
1578        return LanguageUtil.get(companyId, locale, sb.toString());
1579    }
1580
1581    public String getPortletTitle(String portletId, User user) {
1582        StringBuilder sb = new StringBuilder();
1583
1584        sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1585        sb.append(StringPool.PERIOD);
1586        sb.append(portletId);
1587
1588        return LanguageUtil.get(
1589            user.getCompanyId(), user.getLocale(), sb.toString());
1590    }
1591
1592    public String getPortletTitle(
1593        Portlet portlet, long companyId, String languageId) {
1594
1595        return getPortletTitle(portlet.getPortletId(), companyId, languageId);
1596    }
1597
1598    public String getPortletTitle(
1599        Portlet portlet, long companyId, Locale locale) {
1600
1601        return getPortletTitle(portlet.getPortletId(), companyId, locale);
1602    }
1603
1604    public String getPortletTitle(Portlet portlet, User user) {
1605        return getPortletTitle(portlet.getPortletId(), user);
1606    }
1607
1608    public String getPortletTitle(
1609        Portlet portlet, ServletContext servletContext, Locale locale) {
1610
1611        PortletConfig portletConfig = PortletConfigFactory.create(
1612            portlet, servletContext);
1613
1614        ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
1615
1616        return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
1617    }
1618
1619    public String getPortletXmlFileName()
1620        throws PortalException, SystemException {
1621
1622        if (PrefsPropsUtil.getBoolean(
1623                PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
1624                PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
1625
1626            return PORTLET_XML_FILE_NAME_CUSTOM;
1627        }
1628        else {
1629            return PORTLET_XML_FILE_NAME_STANDARD;
1630        }
1631    }
1632
1633    public PortletPreferences getPreferences(HttpServletRequest request) {
1634        RenderRequest renderRequest = (RenderRequest)request.getAttribute(
1635            JavaConstants.JAVAX_PORTLET_REQUEST);
1636
1637        PortletPreferences prefs = null;
1638
1639        if (renderRequest != null) {
1640            PortletPreferencesWrapper prefsWrapper =
1641                (PortletPreferencesWrapper)renderRequest.getPreferences();
1642
1643            prefs = prefsWrapper.getPreferencesImpl();
1644        }
1645
1646        return prefs;
1647    }
1648
1649    public PreferencesValidator getPreferencesValidator(Portlet portlet) {
1650        PortletApp portletApp = portlet.getPortletApp();
1651
1652        if (portletApp.isWARFile()) {
1653            PortletBag portletBag = PortletBagPool.get(
1654                portlet.getRootPortletId());
1655
1656            return portletBag.getPreferencesValidatorInstance();
1657        }
1658        else {
1659            PreferencesValidator prefsValidator = null;
1660
1661            if (Validator.isNotNull(portlet.getPreferencesValidator())) {
1662                prefsValidator =
1663                    (PreferencesValidator)InstancePool.get(
1664                        portlet.getPreferencesValidator());
1665            }
1666
1667            return prefsValidator;
1668        }
1669    }
1670
1671    public User getSelectedUser(HttpServletRequest request)
1672        throws PortalException, RemoteException, SystemException {
1673
1674        return getSelectedUser(request, true);
1675    }
1676
1677    public User getSelectedUser(
1678            HttpServletRequest request, boolean checkPermission)
1679        throws PortalException, RemoteException, SystemException {
1680
1681        long userId = ParamUtil.getLong(request, "p_u_i_d");
1682
1683        User user = null;
1684
1685        try {
1686            if (checkPermission) {
1687                user = UserServiceUtil.getUserById(userId);
1688            }
1689            else {
1690                user = UserLocalServiceUtil.getUserById(userId);
1691            }
1692        }
1693        catch (NoSuchUserException nsue) {
1694        }
1695
1696        return user;
1697    }
1698
1699    public User getSelectedUser(ActionRequest actionRequest)
1700        throws PortalException, RemoteException, SystemException {
1701
1702        return getSelectedUser(actionRequest, true);
1703    }
1704
1705    public User getSelectedUser(
1706            ActionRequest actionRequest, boolean checkPermission)
1707        throws PortalException, RemoteException, SystemException {
1708
1709        return getSelectedUser(
1710            getHttpServletRequest(actionRequest), checkPermission);
1711    }
1712
1713    public User getSelectedUser(RenderRequest renderRequest)
1714        throws PortalException, RemoteException, SystemException {
1715
1716        return getSelectedUser(renderRequest, true);
1717    }
1718
1719    public User getSelectedUser(
1720            RenderRequest renderRequest, boolean checkPermission)
1721        throws PortalException, RemoteException, SystemException {
1722
1723        return getSelectedUser(
1724            getHttpServletRequest(renderRequest), checkPermission);
1725    }
1726
1727    public String getStrutsAction(HttpServletRequest request) {
1728        String strutsAction = ParamUtil.getString(request, "struts_action");
1729
1730        if (Validator.isNotNull(strutsAction)) {
1731
1732            // This method should only return a Struts action if you're dealing
1733            // with a regular HTTP servlet request, not a portlet HTTP servlet
1734            // request.
1735
1736            return StringPool.BLANK;
1737        }
1738
1739        return _getPortletParam(request, "struts_action");
1740    }
1741
1742    public String[] getSystemCommunityRoles() {
1743        return _allSystemCommunityRoles;
1744    }
1745
1746    public String[] getSystemGroups() {
1747        return _allSystemGroups;
1748    }
1749
1750    public String[] getSystemOrganizationRoles() {
1751        return _allSystemOrganizationRoles;
1752    }
1753
1754    public String[] getSystemRoles() {
1755        return _allSystemRoles;
1756    }
1757
1758    public UploadPortletRequest getUploadPortletRequest(
1759        ActionRequest actionRequest) {
1760
1761        ActionRequestImpl actionRequestImpl = (ActionRequestImpl)actionRequest;
1762
1763        DynamicServletRequest dynamicRequest =
1764            (DynamicServletRequest)actionRequestImpl.getHttpServletRequest();
1765
1766        HttpServletRequestWrapper requestWrapper =
1767            (HttpServletRequestWrapper)dynamicRequest.getRequest();
1768
1769        UploadServletRequest uploadRequest = getUploadServletRequest(
1770            requestWrapper);
1771
1772        return new UploadPortletRequestImpl(
1773            uploadRequest,
1774            PortalUtil.getPortletNamespace(actionRequestImpl.getPortletName()));
1775    }
1776
1777    public UploadServletRequest getUploadServletRequest(
1778        HttpServletRequest request) {
1779
1780        HttpServletRequestWrapper requestWrapper = null;
1781
1782        if (request instanceof HttpServletRequestWrapper) {
1783            requestWrapper = (HttpServletRequestWrapper)request;
1784        }
1785
1786        UploadServletRequest uploadRequest = null;
1787
1788        while (uploadRequest == null) {
1789
1790            // Find the underlying UploadServletRequest wrapper. For example,
1791            // WebSphere wraps all requests with ProtectedServletRequest.
1792
1793            if (requestWrapper instanceof UploadServletRequest) {
1794                uploadRequest = (UploadServletRequest)requestWrapper;
1795            }
1796            else {
1797                HttpServletRequest parentRequest =
1798                    (HttpServletRequest)requestWrapper.getRequest();
1799
1800                if (!(parentRequest instanceof HttpServletRequestWrapper)) {
1801
1802                    // This block should never be reached unless this method is
1803                    // called from a hot deployable portlet. See LayoutAction.
1804
1805                    uploadRequest = new UploadServletRequestImpl(parentRequest);
1806
1807                    break;
1808                }
1809                else {
1810                    requestWrapper = (HttpServletRequestWrapper)parentRequest;
1811                }
1812            }
1813        }
1814
1815        return uploadRequest;
1816    }
1817
1818    public Date getUptime() {
1819        return UP_TIME;
1820    }
1821
1822    public String getURLWithSessionId(String url, String sessionId) {
1823        if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
1824            return url;
1825        }
1826
1827        // LEP-4787
1828
1829        int x = url.indexOf(StringPool.SEMICOLON);
1830
1831        if (x != -1) {
1832            return url;
1833        }
1834
1835        x = url.indexOf(StringPool.QUESTION);
1836
1837        if (x != -1) {
1838            StringBuilder sb = new StringBuilder();
1839
1840            sb.append(url.substring(0, x));
1841            sb.append(_JSESSIONID);
1842            sb.append(sessionId);
1843            sb.append(url.substring(x));
1844
1845            return sb.toString();
1846        }
1847
1848        // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
1849        // http://www.abc.com/;jsessionid=XYZ does work.
1850
1851        x = url.indexOf(StringPool.DOUBLE_SLASH);
1852
1853        StringBuilder sb = new StringBuilder();
1854
1855        sb.append(url);
1856
1857        if (x != -1) {
1858            int y = url.lastIndexOf(StringPool.SLASH);
1859
1860            if (x + 1 == y) {
1861                sb.append(StringPool.SLASH);
1862            }
1863        }
1864
1865        sb.append(_JSESSIONID);
1866        sb.append(sessionId);
1867
1868        return sb.toString();
1869    }
1870
1871    public User getUser(HttpServletRequest request)
1872        throws PortalException, SystemException {
1873
1874        long userId = getUserId(request);
1875
1876        if (userId <= 0) {
1877
1878            // Portlet WARs may have the correct remote user and not have the
1879            // correct user id because the user id is saved in the session
1880            // and may not be accessible by the portlet WAR's session. This
1881            // behavior is inconsistent across different application servers.
1882
1883            String remoteUser = request.getRemoteUser();
1884
1885            if (remoteUser == null) {
1886                return null;
1887            }
1888
1889            userId = GetterUtil.getLong(remoteUser);
1890        }
1891
1892        User user = (User)request.getAttribute(WebKeys.USER);
1893
1894        if (user == null) {
1895            user = UserLocalServiceUtil.getUserById(userId);
1896
1897            request.setAttribute(WebKeys.USER, user);
1898        }
1899
1900        return user;
1901    }
1902
1903    public User getUser(ActionRequest actionRequest)
1904        throws PortalException, SystemException {
1905
1906        return getUser(getHttpServletRequest(actionRequest));
1907    }
1908
1909    public User getUser(RenderRequest renderRequest)
1910        throws PortalException, SystemException {
1911
1912        return getUser(getHttpServletRequest(renderRequest));
1913    }
1914
1915    public long getUserId(HttpServletRequest request) {
1916        Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
1917
1918        if (userIdObj != null) {
1919            return userIdObj.longValue();
1920        }
1921
1922        if (!PropsValues.PORTAL_JAAS_ENABLE &&
1923            PropsValues.PORTAL_IMPERSONATION_ENABLE) {
1924
1925            String doAsUserIdString = ParamUtil.getString(
1926                request, "doAsUserId");
1927
1928            try {
1929                long doAsUserId = getDoAsUserId(request, doAsUserIdString);
1930
1931                if (doAsUserId > 0) {
1932                    if (_log.isDebugEnabled()) {
1933                        _log.debug("Impersonating user " + doAsUserId);
1934                    }
1935
1936                    return doAsUserId;
1937                }
1938            }
1939            catch (Exception e) {
1940                _log.error("Unable to impersonate user " + doAsUserIdString, e);
1941            }
1942        }
1943
1944        HttpSession session = request.getSession();
1945
1946        userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
1947
1948        if (userIdObj != null) {
1949            request.setAttribute(WebKeys.USER_ID, userIdObj);
1950
1951            return userIdObj.longValue();
1952        }
1953        else {
1954            return 0;
1955        }
1956    }
1957
1958    public long getUserId(ActionRequest actionRequest) {
1959        return getUserId(getHttpServletRequest(actionRequest));
1960    }
1961
1962    public long getUserId(RenderRequest renderRequest) {
1963        return getUserId(getHttpServletRequest(renderRequest));
1964    }
1965
1966    public String getUserName(long userId, String defaultUserName) {
1967        return getUserName(
1968            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
1969    }
1970
1971    public String getUserName(
1972        long userId, String defaultUserName, String userAttribute) {
1973
1974        return getUserName(userId, defaultUserName, userAttribute, null);
1975    }
1976
1977    public String getUserName(
1978        long userId, String defaultUserName, HttpServletRequest request) {
1979
1980        return getUserName(
1981            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
1982    }
1983
1984    public String getUserName(
1985        long userId, String defaultUserName, String userAttribute,
1986        HttpServletRequest request) {
1987
1988        String userName = defaultUserName;
1989
1990        try {
1991            User user = UserLocalServiceUtil.getUserById(userId);
1992
1993            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
1994                userName = user.getFullName();
1995            }
1996            else {
1997                userName = user.getScreenName();
1998            }
1999
2000            if (request != null) {
2001                Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2002
2003                PortletURL portletURL = new PortletURLImpl(
2004                    request, PortletKeys.DIRECTORY, layout.getPlid(),
2005                    PortletRequest.RENDER_PHASE);
2006
2007                portletURL.setWindowState(WindowState.MAXIMIZED);
2008                portletURL.setPortletMode(PortletMode.VIEW);
2009
2010                portletURL.setParameter(
2011                    "struts_action", "/directory/edit_user");
2012                portletURL.setParameter(
2013                    "p_u_i_d", String.valueOf(user.getUserId()));
2014
2015                userName =
2016                    "<a href=\"" + portletURL.toString() + "\">" + userName +
2017                        "</a>";
2018            }
2019        }
2020        catch (Exception e) {
2021        }
2022
2023        return userName;
2024    }
2025
2026    public String getUserPassword(HttpSession session) {
2027        return (String)session.getAttribute(WebKeys.USER_PASSWORD);
2028    }
2029
2030    public String getUserPassword(HttpServletRequest request) {
2031        HttpSession session = request.getSession();
2032
2033        return getUserPassword(session);
2034    }
2035
2036    public String getUserPassword(ActionRequest actionRequest) {
2037        return getUserPassword(getHttpServletRequest(actionRequest));
2038    }
2039
2040    public String getUserPassword(RenderRequest renderRequest) {
2041        return getUserPassword(getHttpServletRequest(renderRequest));
2042    }
2043
2044    public String getUserValue(long userId, String param, String defaultValue)
2045        throws SystemException {
2046
2047        if (Validator.isNotNull(defaultValue)) {
2048            return defaultValue;
2049        }
2050        else {
2051            try {
2052                User user = UserLocalServiceUtil.getUserById(userId);
2053
2054                return BeanPropertiesUtil.getString(user, param, defaultValue);
2055            }
2056            catch (PortalException pe) {
2057                return StringPool.BLANK;
2058            }
2059        }
2060    }
2061
2062    public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay) {
2063        String widgetURL =
2064            themeDisplay.getPortalURL() + "/widget" +
2065                getLayoutURL(themeDisplay) + "/-/";
2066
2067        FriendlyURLMapper friendlyURLMapper =
2068            portlet.getFriendlyURLMapperInstance();
2069
2070        if (friendlyURLMapper != null) {
2071            widgetURL += friendlyURLMapper.getMapping();
2072        }
2073        else {
2074            widgetURL += portlet.getPortletId();
2075        }
2076
2077        return widgetURL;
2078    }
2079
2080    public boolean isMethodGet(PortletRequest portletRequest) {
2081        HttpServletRequest request = getHttpServletRequest(portletRequest);
2082
2083        String method = GetterUtil.getString(request.getMethod());
2084
2085        if (method.equalsIgnoreCase(HttpMethods.GET)) {
2086            return true;
2087        }
2088        else {
2089            return false;
2090        }
2091    }
2092
2093    public boolean isMethodPost(PortletRequest portletRequest) {
2094        HttpServletRequest request = getHttpServletRequest(portletRequest);
2095
2096        String method = GetterUtil.getString(request.getMethod());
2097
2098        if (method.equalsIgnoreCase(HttpMethods.POST)) {
2099            return true;
2100        }
2101        else {
2102            return false;
2103        }
2104    }
2105
2106    public boolean isLayoutFriendliable(Layout layout) {
2107        return GetterUtil.getBoolean(
2108            PropsUtil.get(
2109                PropsKeys.LAYOUT_URL_FRIENDLIABLE,
2110                new Filter(layout.getType())),
2111            true);
2112    }
2113
2114    public boolean isLayoutParentable(Layout layout) {
2115        return isLayoutParentable(layout.getType());
2116    }
2117
2118    public boolean isLayoutParentable(String type) {
2119        return GetterUtil.getBoolean(
2120            PropsUtil.get(PropsKeys.LAYOUT_PARENTABLE, new Filter(type)), true);
2121    }
2122
2123    public boolean isLayoutSitemapable(Layout layout) {
2124        if (layout.isPrivateLayout()) {
2125            return false;
2126        }
2127
2128        return GetterUtil.getBoolean(PropsUtil.get(
2129            PropsKeys.LAYOUT_SITEMAPABLE, new Filter(layout.getType())), true);
2130    }
2131
2132    public boolean isReservedParameter(String name) {
2133        return _reservedParams.contains(name);
2134    }
2135
2136    public boolean isSystemGroup(String groupName) {
2137        if (groupName == null) {
2138            return false;
2139        }
2140
2141        groupName = groupName.trim();
2142
2143        int pos = Arrays.binarySearch(
2144            _sortedSystemGroups, groupName, new StringComparator());
2145
2146        if (pos >= 0) {
2147            return true;
2148        }
2149        else {
2150            return false;
2151        }
2152    }
2153
2154    public boolean isSystemRole(String roleName) {
2155        if (roleName == null) {
2156            return false;
2157        }
2158
2159        roleName = roleName.trim();
2160
2161        int pos = Arrays.binarySearch(
2162            _sortedSystemRoles, roleName, new StringComparator());
2163
2164        if (pos >= 0) {
2165            return true;
2166        }
2167        else {
2168            pos = Arrays.binarySearch(
2169                _sortedSystemCommunityRoles, roleName, new StringComparator());
2170
2171            if (pos >= 0) {
2172                return true;
2173            }
2174            else {
2175                pos = Arrays.binarySearch(
2176                    _sortedSystemOrganizationRoles, roleName,
2177                    new StringComparator());
2178
2179                if (pos >= 0) {
2180                    return true;
2181                }
2182            }
2183        }
2184
2185        return false;
2186    }
2187
2188    public boolean isUpdateAvailable()
2189        throws PortalException, SystemException {
2190
2191        return PluginPackageUtil.isUpdateAvailable();
2192    }
2193
2194    public void renderPage(
2195            StringBuilder sb, ServletContext servletContext,
2196            HttpServletRequest request, HttpServletResponse response,
2197            String path)
2198        throws IOException, ServletException {
2199
2200        RequestDispatcher requestDispatcher =
2201            servletContext.getRequestDispatcher(path);
2202
2203        StringServletResponse stringResponse = new StringServletResponse(
2204            response);
2205
2206        requestDispatcher.include(request, stringResponse);
2207
2208        sb.append(stringResponse.getString());
2209    }
2210
2211    public void renderPortlet(
2212            StringBuilder sb, ServletContext servletContext,
2213            HttpServletRequest request, HttpServletResponse response,
2214            Portlet portlet, String queryString)
2215        throws IOException, ServletException {
2216
2217        renderPortlet(
2218            sb, servletContext, request, response, portlet, queryString, null,
2219            null, null);
2220    }
2221
2222    public void renderPortlet(
2223            StringBuilder sb, ServletContext servletContext,
2224            HttpServletRequest request, HttpServletResponse response,
2225            Portlet portlet, String queryString, String columnId,
2226            Integer columnPos, Integer columnCount)
2227        throws IOException, ServletException {
2228
2229        renderPortlet(
2230            sb, servletContext, request, response, portlet, queryString,
2231            columnId, columnPos, columnCount, null);
2232    }
2233
2234    public void renderPortlet(
2235            StringBuilder sb, ServletContext servletContext,
2236            HttpServletRequest request, HttpServletResponse response,
2237            Portlet portlet, String queryString, String columnId,
2238            Integer columnPos, Integer columnCount, String path)
2239        throws IOException, ServletException {
2240
2241        queryString = GetterUtil.getString(queryString);
2242        columnId = GetterUtil.getString(columnId);
2243
2244        if (columnPos == null) {
2245            columnPos = new Integer(0);
2246        }
2247
2248        if (columnCount == null) {
2249            columnCount = new Integer(0);
2250        }
2251
2252        request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
2253        request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
2254        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
2255        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
2256        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
2257
2258        if (path == null) {
2259            path = "/html/portal/render_portlet.jsp";
2260        }
2261
2262        RequestDispatcher requestDispatcher =
2263            servletContext.getRequestDispatcher(path);
2264
2265        if (sb != null) {
2266            StringServletResponse stringResponse = new StringServletResponse(
2267                response);
2268
2269            requestDispatcher.include(request, stringResponse);
2270
2271            sb.append(stringResponse.getString());
2272        }
2273        else {
2274
2275            // LEP-766
2276
2277            response.setContentType(ContentTypes.TEXT_HTML_UTF8);
2278
2279            requestDispatcher.include(request, response);
2280        }
2281    }
2282
2283    public void sendError(
2284            Exception e, HttpServletRequest request,
2285            HttpServletResponse response)
2286        throws IOException, ServletException {
2287
2288        sendError(0, e, request, response);
2289    }
2290
2291    public void sendError(
2292            int status, Exception e, HttpServletRequest request,
2293            HttpServletResponse response)
2294        throws IOException, ServletException {
2295
2296        if (status == 0) {
2297            if (e instanceof PrincipalException) {
2298                status = HttpServletResponse.SC_FORBIDDEN;
2299            }
2300            else {
2301                String name = e.getClass().getName();
2302
2303                name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
2304
2305                if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
2306                    status = HttpServletResponse.SC_NOT_FOUND;
2307                }
2308            }
2309
2310            if (status == 0) {
2311                status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
2312            }
2313        }
2314
2315        HttpSession session = request.getSession();
2316
2317        ServletContext servletContext = session.getServletContext();
2318
2319        String redirect = PATH_MAIN + "/portal/status";
2320
2321        if (e instanceof NoSuchLayoutException &&
2322            Validator.isNotNull(
2323                PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
2324
2325            response.setStatus(status);
2326
2327            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
2328
2329            RequestDispatcher requestDispatcher =
2330                servletContext.getRequestDispatcher(redirect);
2331
2332            if (requestDispatcher != null) {
2333                requestDispatcher.forward(request, response);
2334            }
2335        }
2336        else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
2337            response.setStatus(status);
2338
2339            SessionErrors.add(request, e.getClass().getName(), e);
2340
2341            RequestDispatcher requestDispatcher =
2342                servletContext.getRequestDispatcher(redirect);
2343
2344            if (requestDispatcher != null) {
2345                requestDispatcher.forward(request, response);
2346            }
2347        }
2348        else {
2349            if (e != null) {
2350                response.sendError(status, e.getMessage());
2351            }
2352            else {
2353                response.sendError(status);
2354            }
2355        }
2356    }
2357
2358    public void sendError(
2359            Exception e, ActionRequest actionRequest,
2360            ActionResponse actionResponse)
2361        throws IOException {
2362
2363        sendError(0, e, actionRequest, actionResponse);
2364    }
2365
2366    public void sendError(
2367            int status, Exception e, ActionRequest actionRequest,
2368            ActionResponse actionResponse)
2369        throws IOException {
2370
2371        StringBuilder sb = new StringBuilder();
2372
2373        sb.append(PATH_MAIN);
2374        sb.append("/portal/status?status=");
2375        sb.append(status);
2376        sb.append("&exception=");
2377        sb.append(e.getClass().getName());
2378        sb.append("&previousURL=");
2379        sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
2380
2381        actionResponse.sendRedirect(sb.toString());
2382    }
2383
2384    /**
2385     * Sets the subtitle for a page. This is just a hint and can be overridden
2386     * by subsequent calls. The last call to this method wins.
2387     *
2388     * @param       subtitle the subtitle for a page
2389     * @param       request the HTTP servlet request
2390     */
2391    public void setPageSubtitle(String subtitle, HttpServletRequest request) {
2392        request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
2393    }
2394
2395    /**
2396     * Sets the whole title for a page. This is just a hint and can be
2397     * overridden by subsequent calls. The last call to this method wins.
2398     *
2399     * @param       title the whole title for a page
2400     * @param       request the HTTP servlet request
2401     */
2402    public void setPageTitle(String title, HttpServletRequest request) {
2403        request.setAttribute(WebKeys.PAGE_TITLE, title);
2404    }
2405
2406    /**
2407     * Sets the port obtained on the first request to the portal.
2408     *
2409     * @param       request the HTTP servlet request
2410     */
2411    public void setPortalPort(HttpServletRequest request) {
2412        if (_portalPort.intValue() == -1) {
2413            synchronized (_portalPort) {
2414                _portalPort = new Integer(request.getServerPort());
2415            }
2416        }
2417    }
2418
2419    public void storePreferences(PortletPreferences prefs)
2420        throws IOException, ValidatorException {
2421
2422        PortletPreferencesWrapper prefsWrapper =
2423            (PortletPreferencesWrapper)prefs;
2424
2425        PortletPreferencesImpl prefsImpl = prefsWrapper.getPreferencesImpl();
2426
2427        prefsImpl.store();
2428    }
2429
2430    public String transformCustomSQL(String sql) {
2431        if ((_customSqlClassNames == null) ||
2432            (_customSqlClassNameIds == null)) {
2433
2434            _initCustomSQL();
2435        }
2436
2437        return StringUtil.replace(
2438            sql, _customSqlClassNames, _customSqlClassNameIds);
2439    }
2440
2441    public PortletMode updatePortletMode(
2442        String portletId, User user, Layout layout, PortletMode portletMode,
2443        HttpServletRequest request) {
2444
2445        LayoutTypePortlet layoutType =
2446            (LayoutTypePortlet)layout.getLayoutType();
2447
2448        if (portletMode == null || Validator.isNull(portletMode.toString())) {
2449            if (layoutType.hasModeAboutPortletId(portletId)) {
2450                return LiferayPortletMode.ABOUT;
2451            }
2452            else if (layoutType.hasModeConfigPortletId(portletId)) {
2453                return LiferayPortletMode.CONFIG;
2454            }
2455            else if (layoutType.hasModeEditPortletId(portletId)) {
2456                return PortletMode.EDIT;
2457            }
2458            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
2459                return LiferayPortletMode.EDIT_DEFAULTS;
2460            }
2461            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
2462                return LiferayPortletMode.EDIT_GUEST;
2463            }
2464            else if (layoutType.hasModeHelpPortletId(portletId)) {
2465                return PortletMode.HELP;
2466            }
2467            else if (layoutType.hasModePreviewPortletId(portletId)) {
2468                return LiferayPortletMode.PREVIEW;
2469            }
2470            else if (layoutType.hasModePrintPortletId(portletId)) {
2471                return LiferayPortletMode.PRINT;
2472            }
2473            else {
2474                return PortletMode.VIEW;
2475            }
2476        }
2477        else {
2478            boolean updateLayout = false;
2479
2480            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
2481                !layoutType.hasModeAboutPortletId(portletId)) {
2482
2483                layoutType.addModeAboutPortletId(portletId);
2484
2485                updateLayout = true;
2486            }
2487            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
2488                     !layoutType.hasModeConfigPortletId(portletId)) {
2489
2490                layoutType.addModeConfigPortletId(portletId);
2491
2492                updateLayout = true;
2493            }
2494            else if (portletMode.equals(PortletMode.EDIT) &&
2495                     !layoutType.hasModeEditPortletId(portletId)) {
2496
2497                layoutType.addModeEditPortletId(portletId);
2498
2499                updateLayout = true;
2500            }
2501            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
2502                     !layoutType.hasModeEditDefaultsPortletId(portletId)) {
2503
2504                layoutType.addModeEditDefaultsPortletId(portletId);
2505
2506                updateLayout = true;
2507            }
2508            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
2509                     !layoutType.hasModeEditGuestPortletId(portletId)) {
2510
2511                layoutType.addModeEditGuestPortletId(portletId);
2512
2513                updateLayout = true;
2514            }
2515            else if (portletMode.equals(PortletMode.HELP) &&
2516                     !layoutType.hasModeHelpPortletId(portletId)) {
2517
2518                layoutType.addModeHelpPortletId(portletId);
2519
2520                updateLayout = true;
2521            }
2522            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
2523                     !layoutType.hasModePreviewPortletId(portletId)) {
2524
2525                layoutType.addModePreviewPortletId(portletId);
2526
2527                updateLayout = true;
2528            }
2529            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
2530                     !layoutType.hasModePrintPortletId(portletId)) {
2531
2532                layoutType.addModePrintPortletId(portletId);
2533
2534                updateLayout = true;
2535            }
2536            else if (portletMode.equals(PortletMode.VIEW) &&
2537                     !layoutType.hasModeViewPortletId(portletId)) {
2538
2539                layoutType.removeModesPortletId(portletId);
2540
2541                updateLayout = true;
2542            }
2543
2544            if (updateLayout) {
2545                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
2546
2547                if (layoutClone != null) {
2548                    layoutClone.update(
2549                        request, layout.getPlid(), layout.getTypeSettings());
2550                }
2551            }
2552
2553            return portletMode;
2554        }
2555    }
2556
2557    public WindowState updateWindowState(
2558        String portletId, User user, Layout layout, WindowState windowState,
2559        HttpServletRequest request) {
2560
2561        LayoutTypePortlet layoutType =
2562            (LayoutTypePortlet)layout.getLayoutType();
2563
2564        if ((windowState == null) ||
2565            (Validator.isNull(windowState.toString()))) {
2566
2567            if (layoutType.hasStateMaxPortletId(portletId)) {
2568                return WindowState.MAXIMIZED;
2569            }
2570            else if (layoutType.hasStateMinPortletId(portletId)) {
2571                return WindowState.MINIMIZED;
2572            }
2573            else {
2574                return WindowState.NORMAL;
2575            }
2576        }
2577        else {
2578            boolean updateLayout = false;
2579
2580            if (windowState.equals(WindowState.MAXIMIZED) &&
2581                !layoutType.hasStateMaxPortletId(portletId)) {
2582
2583                layoutType.addStateMaxPortletId(portletId);
2584
2585                updateLayout = false;
2586            }
2587            else if (windowState.equals(WindowState.MINIMIZED) &&
2588                     !layoutType.hasStateMinPortletId(portletId)) {
2589
2590                layoutType.addStateMinPortletId(portletId);
2591
2592                updateLayout = true;
2593            }
2594            else if (windowState.equals(WindowState.NORMAL) &&
2595                     !layoutType.hasStateNormalPortletId(portletId)) {
2596
2597                layoutType.removeStatesPortletId(portletId);
2598
2599                updateLayout = true;
2600            }
2601
2602            if (updateLayout) {
2603                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
2604
2605                if (layoutClone != null) {
2606                    layoutClone.update(
2607                        request, layout.getPlid(), layout.getTypeSettings());
2608                }
2609            }
2610
2611            return windowState;
2612        }
2613    }
2614
2615    protected long getDoAsUserId(
2616            HttpServletRequest request, String doAsUserIdString)
2617        throws Exception {
2618
2619        if (Validator.isNull(doAsUserIdString)) {
2620            return 0;
2621        }
2622
2623        long doAsUserId = 0;
2624
2625        try {
2626            Company company = getCompany(request);
2627
2628            doAsUserId = GetterUtil.getLong(
2629                Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
2630        }
2631        catch (Exception e) {
2632            if (_log.isWarnEnabled()) {
2633                _log.warn(
2634                    "Unable to impersonate " + doAsUserIdString +
2635                        " because the string cannot be decrypted",
2636                    e);
2637            }
2638
2639            return 0;
2640        }
2641
2642        String path = GetterUtil.getString(request.getPathInfo());
2643
2644        if (_log.isDebugEnabled()) {
2645            _log.debug("doAsUserId path " + path);
2646        }
2647
2648        String strutsAction = getStrutsAction(request);
2649
2650        if (_log.isDebugEnabled()) {
2651            _log.debug("Struts action " + strutsAction);
2652        }
2653
2654        String actionName = _getPortletParam(request, "actionName");
2655
2656        if (_log.isDebugEnabled()) {
2657            _log.debug("Action name " + actionName);
2658        }
2659
2660        boolean alwaysAllowDoAsUser = false;
2661
2662        if (path.equals("/portal/fckeditor") ||
2663            strutsAction.equals("/document_library/edit_file_entry") ||
2664            strutsAction.equals("/image_gallery/edit_image") ||
2665            strutsAction.equals("/wiki/edit_page_attachment") ||
2666            actionName.equals("addFile")) {
2667
2668            alwaysAllowDoAsUser = true;
2669        }
2670
2671        if (_log.isDebugEnabled()) {
2672            if (alwaysAllowDoAsUser) {
2673                _log.debug(
2674                    "doAsUserId path or Struts action is always allowed");
2675            }
2676            else {
2677                _log.debug(
2678                    "doAsUserId path is Struts action not always allowed");
2679            }
2680        }
2681
2682        if (alwaysAllowDoAsUser) {
2683            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
2684
2685            return doAsUserId;
2686        }
2687
2688        HttpSession session = request.getSession();
2689
2690        Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
2691
2692        if (realUserIdObj == null) {
2693            return 0;
2694        }
2695
2696        User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
2697
2698        long[] organizationIds = doAsUser.getOrganizationIds();
2699
2700        User realUser = UserLocalServiceUtil.getUserById(
2701            realUserIdObj.longValue());
2702        boolean checkGuest = true;
2703
2704        PermissionChecker permissionChecker = null;
2705
2706        try {
2707            permissionChecker = PermissionCheckerFactory.create(
2708                realUser, checkGuest);
2709
2710            if (doAsUser.isDefaultUser() ||
2711                UserPermissionUtil.contains(
2712                    permissionChecker, doAsUserId, organizationIds,
2713                    ActionKeys.IMPERSONATE)) {
2714
2715                request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
2716
2717                return doAsUserId;
2718            }
2719            else {
2720                _log.error(
2721                    "User " + realUserIdObj + " does not have the permission " +
2722                        "to impersonate " + doAsUserId);
2723
2724                return 0;
2725            }
2726        }
2727        finally {
2728            try {
2729                PermissionCheckerFactory.recycle(permissionChecker);
2730            }
2731            catch (Exception e) {
2732            }
2733        }
2734    }
2735
2736    private String _getCurrentURL(HttpServletRequest request) {
2737        StringBuilder sb = new StringBuilder();
2738
2739        StringBuffer requestURL = request.getRequestURL();
2740
2741        if (requestURL != null) {
2742            sb.append(requestURL.toString());
2743        }
2744
2745        String queryString = request.getQueryString();
2746
2747        if (Validator.isNull(queryString)) {
2748            return sb.toString();
2749        }
2750
2751        String portletId = request.getParameter("p_p_id");
2752
2753        String redirectParam = "redirect";
2754
2755        if (Validator.isNotNull(portletId)) {
2756            redirectParam = getPortletNamespace(portletId) + redirectParam;
2757        }
2758
2759        Map<String, String[]> parameterMap = HttpUtil.parameterMapFromString(
2760            queryString);
2761
2762        String[] redirectValues = parameterMap.get(redirectParam);
2763
2764        if ((redirectValues != null) && (redirectValues.length > 0)) {
2765
2766            // Prevent the redirect for GET requests from growing indefinitely
2767            // and using up all the available space by remembering only the
2768            // first redirect.
2769
2770            String redirect = HttpUtil.decodeURL(
2771                GetterUtil.getString(redirectValues[0]));
2772
2773            int pos = redirect.indexOf(StringPool.QUESTION);
2774
2775            if (pos != -1) {
2776                String subqueryString = redirect.substring(
2777                    pos + 1, redirect.length());
2778
2779                Map<String, String[]> subparameterMap =
2780                    HttpUtil.parameterMapFromString(subqueryString);
2781
2782                String[] subredirectValues = subparameterMap.get(redirectParam);
2783
2784                if ((subredirectValues != null) &&
2785                    (subredirectValues.length > 0)) {
2786
2787                    String subredirect = HttpUtil.decodeURL(
2788                        GetterUtil.getString(subredirectValues[0]));
2789
2790                    parameterMap.put(redirectParam, new String[] {subredirect});
2791
2792                    queryString = HttpUtil.parameterMapToString(
2793                        parameterMap, false);
2794                }
2795            }
2796        }
2797
2798        sb.append(StringPool.QUESTION);
2799        sb.append(queryString);
2800
2801        return sb.toString();
2802    }
2803
2804    private long _getPlidFromPortletId(
2805        long groupId, boolean privateLayout, String portletId) {
2806
2807        long plid = LayoutConstants.DEFAULT_PLID;
2808
2809        try {
2810            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2811                groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
2812
2813            for (Layout layout : layouts) {
2814                LayoutTypePortlet layoutTypePortlet =
2815                    (LayoutTypePortlet)layout.getLayoutType();
2816
2817                if (layoutTypePortlet.hasPortletId(portletId)) {
2818                    plid = layout.getPlid();
2819
2820                    break;
2821                }
2822            }
2823        }
2824        catch (SystemException se) {
2825            if (_log.isWarnEnabled()) {
2826                _log.warn(se.getMessage());
2827            }
2828        }
2829
2830        return plid;
2831    }
2832
2833    private String _getPortletParam(HttpServletRequest request, String name) {
2834        String value = null;
2835
2836        int valueCount = 0;
2837
2838        Enumeration<String> enu = request.getParameterNames();
2839
2840        while (enu.hasMoreElements()) {
2841            String curName = enu.nextElement();
2842
2843            int pos = curName.indexOf(StringPool.UNDERLINE + name);
2844
2845            if (pos != -1) {
2846                valueCount++;
2847
2848                // There should never be more than one value
2849
2850                if (valueCount > 1) {
2851                    return StringPool.BLANK;
2852                }
2853
2854                String curValue = ParamUtil.getString(request, curName);
2855
2856                if (Validator.isNotNull(curValue)) {
2857
2858                    // The Struts action must be for the correct portlet
2859
2860                    String portletId1 = curName.substring(1, pos);
2861                    String portletId2 = ParamUtil.getString(request, "p_p_id");
2862
2863                    if (portletId1.equals(portletId2)) {
2864                        value = curValue;
2865                    }
2866                }
2867            }
2868        }
2869
2870        if (value == null) {
2871            value = StringPool.BLANK;
2872        }
2873
2874        return value;
2875    }
2876
2877    private void _initCustomSQL() {
2878        _customSqlClassNames = new String[] {
2879            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
2880            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
2881            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
2882            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
2883            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
2884                "BOOKMARKSENTRY$]",
2885            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
2886                "DLFILEENTRY$]",
2887            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
2888            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
2889                "MBMESSAGE$]",
2890            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
2891            "[$FALSE$]",
2892            "[$TRUE$]"
2893        };
2894
2895        DBUtil dbUtil = DBUtil.getInstance();
2896
2897        _customSqlClassNameIds = new String[] {
2898            String.valueOf(PortalUtil.getClassNameId(Organization.class)),
2899            String.valueOf(PortalUtil.getClassNameId(User.class)),
2900            String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
2901            String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
2902            String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
2903            String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
2904            String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
2905            String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
2906            String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
2907            dbUtil.getTemplateFalse(),
2908            dbUtil.getTemplateTrue()
2909        };
2910    }
2911
2912    private static final String _JSESSIONID = ";jsessionid=";
2913
2914    private static Log _log = LogFactory.getLog(PortalImpl.class);
2915
2916    private String _computerAddress;
2917    private String _computerName;
2918    private String _portalLibDir;
2919    private String _cdnHost;
2920    private String _pathContext;
2921    private String _pathFriendlyURLPrivateGroup;
2922    private String _pathFriendlyURLPrivateUser;
2923    private String _pathFriendlyURLPublic;
2924    private String _pathImage;
2925    private String _pathMain;
2926    private Integer _portalPort = new Integer(-1);
2927    private String[] _allSystemCommunityRoles;
2928    private String[] _allSystemGroups;
2929    private String[] _allSystemOrganizationRoles;
2930    private String[] _allSystemRoles;
2931    private String[] _sortedSystemCommunityRoles;
2932    private String[] _sortedSystemGroups;
2933    private String[] _sortedSystemOrganizationRoles;
2934    private String[] _sortedSystemRoles;
2935    private Set<String> _reservedParams;
2936    private String[] _customSqlClassNames = null;
2937    private String[] _customSqlClassNameIds = null;
2938    private Map<String, Long> _plidToPortletIdCache =
2939        new ConcurrentHashMap<String, Long>();
2940
2941}