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