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