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