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