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 (Validator.isNotNull(layoutSet.getVirtualHost())) {
1047            portalURL = getPortalURL(
1048                layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1049                themeDisplay.isSecure());
1050
1051            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1052                (portalURL.startsWith(themeDisplay.getPortalURL()))) {
1053
1054                if (themeDisplay.isWidget()) {
1055                    layoutFriendlyURL =
1056                        PropsValues.WIDGET_SERVLET_MAPPING + layoutFriendlyURL;
1057                }
1058
1059                if (themeDisplay.isI18n()) {
1060                    layoutFriendlyURL =
1061                        StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1062                            layoutFriendlyURL;
1063                }
1064
1065                return portalURL + _pathContext + layoutFriendlyURL;
1066            }
1067        }
1068        else {
1069            if ((layoutSet.getLayoutSetId() != curLayoutSetId) &&
1070                (layout.getGroup().getClassPK() != themeDisplay.getUserId())) {
1071
1072                String virtualHost = themeDisplay.getCompany().getVirtualHost();
1073
1074                if (!virtualHost.equalsIgnoreCase(_LOCALHOST)) {
1075                    portalURL = getPortalURL(
1076                        virtualHost, themeDisplay.getServerPort(),
1077                        themeDisplay.isSecure());
1078                }
1079            }
1080        }
1081
1082        Group group = layout.getGroup();
1083
1084        String friendlyURL = null;
1085
1086        if (layout.isPrivateLayout()) {
1087            if (group.isUser()) {
1088                friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1089            }
1090            else {
1091                friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1092            }
1093        }
1094        else {
1095            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1096        }
1097
1098        if (themeDisplay.isWidget()) {
1099            friendlyURL = PropsValues.WIDGET_SERVLET_MAPPING + friendlyURL;
1100        }
1101
1102        if (themeDisplay.isI18n()) {
1103            friendlyURL =
1104                StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1105                    friendlyURL;
1106        }
1107
1108        return portalURL + _pathContext + friendlyURL + group.getFriendlyURL() +
1109            layoutFriendlyURL;
1110    }
1111
1112    public String getLayoutSetFriendlyURL(
1113            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1114        throws PortalException, SystemException {
1115
1116        if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1117            String portalURL = getPortalURL(
1118                layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1119                themeDisplay.isSecure());
1120
1121            // Use the layout set's virtual host setting only if the layout set
1122            // is already used for the current request
1123
1124            long curLayoutSetId =
1125                themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1126
1127            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1128                (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1129
1130                String layoutSetFriendlyURL = StringPool.BLANK;
1131
1132                if (themeDisplay.isI18n()) {
1133                    layoutSetFriendlyURL =
1134                        StringPool.SLASH + themeDisplay.getI18nLanguageId();
1135                }
1136
1137                return portalURL + _pathContext + layoutSetFriendlyURL;
1138            }
1139        }
1140
1141        Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1142
1143        String friendlyURL = null;
1144
1145        if (layoutSet.isPrivateLayout()) {
1146            if (group.isUser()) {
1147                friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1148            }
1149            else {
1150                friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1151            }
1152        }
1153        else {
1154            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1155        }
1156
1157        if (themeDisplay.isI18n()) {
1158            friendlyURL =
1159                StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1160                    friendlyURL;
1161        }
1162
1163        return _pathContext + friendlyURL + group.getFriendlyURL();
1164    }
1165
1166    public String getLayoutTarget(Layout layout) {
1167        UnicodeProperties typeSettingsProps =
1168            layout.getTypeSettingsProperties();
1169
1170        String target = typeSettingsProps.getProperty("target");
1171
1172        if (Validator.isNull(target)) {
1173            target = StringPool.BLANK;
1174        }
1175        else {
1176            target = "target=\"" + target + "\"";
1177        }
1178
1179        return target;
1180    }
1181
1182    public String getJsSafePortletId(String portletId) {
1183        return JS.getSafeName(portletId);
1184    }
1185
1186    public Locale getLocale(HttpServletRequest request) {
1187        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1188            WebKeys.THEME_DISPLAY);
1189
1190        if (themeDisplay != null) {
1191            return themeDisplay.getLocale();
1192        }
1193        else {
1194            HttpSession session = request.getSession();
1195
1196            return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1197        }
1198    }
1199
1200    public Locale getLocale(RenderRequest renderRequest) {
1201        return getLocale(getHttpServletRequest(renderRequest));
1202    }
1203
1204    public HttpServletRequest getOriginalServletRequest(
1205        HttpServletRequest request) {
1206
1207        HttpServletRequest originalRequest = request;
1208
1209        while (originalRequest.getClass().getName().startsWith(
1210                    "com.liferay.")) {
1211
1212            // Get original request so that portlets inside portlets render
1213            // properly
1214
1215            originalRequest = (HttpServletRequest)
1216                ((HttpServletRequestWrapper)originalRequest).getRequest();
1217        }
1218
1219        return originalRequest;
1220    }
1221
1222    public String getPathContext() {
1223        return _pathContext;
1224    }
1225
1226    public String getPathFriendlyURLPrivateGroup() {
1227        return _pathFriendlyURLPrivateGroup;
1228    }
1229
1230    public String getPathFriendlyURLPrivateUser() {
1231        return _pathFriendlyURLPrivateUser;
1232    }
1233
1234    public String getPathFriendlyURLPublic() {
1235        return _pathFriendlyURLPublic;
1236    }
1237
1238    public String getPathImage() {
1239        return _pathImage;
1240    }
1241
1242    public String getPathMain() {
1243        return _pathMain;
1244    }
1245
1246    public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1247        if (Validator.isNull(friendlyURL)) {
1248            return LayoutConstants.DEFAULT_PLID;
1249        }
1250
1251        String[] urlParts = friendlyURL.split("\\/", 4);
1252
1253        if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1254            (urlParts.length != 4)) {
1255
1256            return LayoutConstants.DEFAULT_PLID;
1257        }
1258
1259        boolean privateLayout = true;
1260
1261        String urlPrefix = StringPool.SLASH + urlParts[1];
1262
1263        if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
1264            privateLayout = false;
1265        }
1266        else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
1267                 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
1268
1269            privateLayout = true;
1270        }
1271        else {
1272            return LayoutConstants.DEFAULT_PLID;
1273        }
1274
1275        Group group = null;
1276
1277        try {
1278            group = GroupLocalServiceUtil.getFriendlyURLGroup(
1279                companyId, StringPool.SLASH + urlParts[2]);
1280        }
1281        catch (Exception e) {
1282        }
1283
1284        if (group != null) {
1285            Layout layout = null;
1286
1287            try {
1288                layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1289                    group.getGroupId(), privateLayout,
1290                    StringPool.SLASH + urlParts[3]);
1291
1292                return layout.getPlid();
1293            }
1294            catch (Exception e) {
1295            }
1296        }
1297
1298        return LayoutConstants.DEFAULT_PLID;
1299    }
1300
1301    public long getPlidFromPortletId(
1302        long groupId, boolean privateLayout, String portletId) {
1303
1304        long plid = LayoutConstants.DEFAULT_PLID;
1305
1306        StringBuilder sb = new StringBuilder();
1307
1308        sb.append(groupId);
1309        sb.append(StringPool.SPACE);
1310        sb.append(privateLayout);
1311        sb.append(StringPool.SPACE);
1312        sb.append(portletId);
1313
1314        String key = sb.toString();
1315
1316        Long plidObj = _plidToPortletIdCache.get(key);
1317
1318        if (plidObj == null) {
1319            plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1320
1321            if (plid != LayoutConstants.DEFAULT_PLID) {
1322                _plidToPortletIdCache.put(key, plid);
1323            }
1324        }
1325        else {
1326            plid = plidObj.longValue();
1327
1328            boolean validPlid = false;
1329
1330            try {
1331                Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1332
1333                LayoutTypePortlet layoutTypePortlet =
1334                    (LayoutTypePortlet)layout.getLayoutType();
1335
1336                if (layoutTypePortlet.hasPortletId(portletId)) {
1337                    validPlid = true;
1338                }
1339            }
1340            catch (Exception e) {
1341            }
1342
1343            if (!validPlid) {
1344                _plidToPortletIdCache.remove(key);
1345
1346                plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1347
1348                if (plid != LayoutConstants.DEFAULT_PLID) {
1349                    _plidToPortletIdCache.put(key, plid);
1350                }
1351            }
1352        }
1353
1354        return plid;
1355    }
1356
1357    public String getPortalLibDir() {
1358        return _portalLibDir;
1359    }
1360
1361    public int getPortalPort() {
1362        return _portalPort.intValue();
1363    }
1364
1365    public Properties getPortalProperties() {
1366        return PropsUtil.getProperties();
1367    }
1368
1369    public String getPortalURL(ThemeDisplay themeDisplay) {
1370        String serverName = themeDisplay.getServerName();
1371
1372        Layout layout = themeDisplay.getLayout();
1373
1374        if (layout != null) {
1375            LayoutSet layoutSet = layout.getLayoutSet();
1376
1377            if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1378                serverName = layoutSet.getVirtualHost();
1379            }
1380        }
1381
1382        return getPortalURL(
1383            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
1384    }
1385
1386    public String getPortalURL(HttpServletRequest request) {
1387        return getPortalURL(request, request.isSecure());
1388    }
1389
1390    public String getPortalURL(HttpServletRequest request, boolean secure) {
1391        return getPortalURL(
1392            request.getServerName(), request.getServerPort(), secure);
1393    }
1394
1395    public String getPortalURL(PortletRequest portletRequest) {
1396        return getPortalURL(portletRequest, portletRequest.isSecure());
1397    }
1398
1399    public String getPortalURL(PortletRequest portletRequest, boolean secure) {
1400        return getPortalURL(
1401            portletRequest.getServerName(), portletRequest.getServerPort(),
1402            secure);
1403    }
1404
1405    public String getPortalURL(
1406        String serverName, int serverPort, boolean secure) {
1407
1408        StringBuilder sb = new StringBuilder();
1409
1410        if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
1411            sb.append(Http.HTTPS_WITH_SLASH);
1412        }
1413        else {
1414            sb.append(Http.HTTP_WITH_SLASH);
1415        }
1416
1417        if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
1418            sb.append(serverName);
1419        }
1420        else {
1421            sb.append(PropsValues.WEB_SERVER_HOST);
1422        }
1423
1424        if (!secure) {
1425            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
1426                if ((serverPort != Http.HTTP_PORT) &&
1427                    (serverPort != Http.HTTPS_PORT)) {
1428
1429                    sb.append(StringPool.COLON);
1430                    sb.append(serverPort);
1431                }
1432            }
1433            else {
1434                if ((PropsValues.WEB_SERVER_HTTP_PORT != serverPort) &&
1435                    (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT)) {
1436
1437                    sb.append(StringPool.COLON);
1438                    sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
1439                }
1440            }
1441        }
1442
1443        if (secure) {
1444            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
1445                if ((serverPort != Http.HTTP_PORT) &&
1446                    (serverPort != Http.HTTPS_PORT)) {
1447
1448                    sb.append(StringPool.COLON);
1449                    sb.append(serverPort);
1450                }
1451            }
1452            else {
1453                if ((PropsValues.WEB_SERVER_HTTPS_PORT != serverPort) &&
1454                    (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT)) {
1455
1456                    sb.append(StringPool.COLON);
1457                    sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
1458                }
1459            }
1460        }
1461
1462        return sb.toString();
1463    }
1464
1465    public String getPortalWebDir() {
1466        return _portalWebDir;
1467    }
1468
1469    public Object[] getPortletFriendlyURLMapper(
1470            long groupId, boolean privateLayout, String url)
1471        throws PortalException, SystemException {
1472
1473        return getPortletFriendlyURLMapper(groupId, privateLayout, url, null);
1474    }
1475
1476    public Object[] getPortletFriendlyURLMapper(
1477            long groupId, boolean privateLayout, String url,
1478            Map<String, String[]> params)
1479        throws PortalException, SystemException {
1480
1481        boolean foundFriendlyURLMapper = false;
1482
1483        String friendlyURL = url;
1484        String queryString = StringPool.BLANK;
1485
1486        List<FriendlyURLMapper> friendlyURLMappers =
1487            PortletLocalServiceUtil.getFriendlyURLMappers();
1488
1489        Iterator<FriendlyURLMapper> itr = friendlyURLMappers.iterator();
1490
1491        while (itr.hasNext()) {
1492            FriendlyURLMapper friendlyURLMapper = itr.next();
1493
1494            if (url.endsWith(
1495                    StringPool.SLASH + friendlyURLMapper.getMapping())) {
1496
1497                url += StringPool.SLASH;
1498            }
1499
1500            int pos = -1;
1501
1502            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1503                pos = url.indexOf(
1504                    "/-/" + friendlyURLMapper.getMapping() + StringPool.SLASH);
1505            }
1506            else {
1507                pos = url.indexOf(
1508                    StringPool.SLASH + friendlyURLMapper.getMapping() +
1509                        StringPool.SLASH);
1510            }
1511
1512            if (pos != -1) {
1513                foundFriendlyURLMapper = true;
1514
1515                friendlyURL = url.substring(0, pos);
1516
1517                Map<String, String[]> actualParams = null;
1518
1519                if (params != null) {
1520                    actualParams = new HashMap<String, String[]>(params);
1521                }
1522                else {
1523                    actualParams = new HashMap<String, String[]>();
1524                }
1525
1526                /*Object lifecycle = actualParams.get("p_p_lifecycle");
1527
1528                if ((lifecycle == null) ||
1529                    (((String[])lifecycle).length == 0)) {
1530
1531                    actualParams.put("p_p_lifecycle", "0");
1532                }
1533
1534                Object state = actualParams.get("p_p_state");
1535
1536                if ((state == null) || (((String[])state).length == 0)) {
1537                    actualParams.put(
1538                        "p_p_state", WindowState.MAXIMIZED.toString());
1539                }*/
1540
1541                if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1542                    friendlyURLMapper.populateParams(
1543                        url.substring(pos + 2), actualParams);
1544                }
1545                else {
1546                    friendlyURLMapper.populateParams(
1547                        url.substring(pos), actualParams);
1548                }
1549
1550                queryString =
1551                    StringPool.AMPERSAND +
1552                        HttpUtil.parameterMapToString(actualParams, false);
1553
1554                break;
1555            }
1556        }
1557
1558        if (!foundFriendlyURLMapper) {
1559            int x = url.indexOf("/-/");
1560
1561            if (x != -1) {
1562                int y = url.indexOf(StringPool.SLASH, x + 3);
1563
1564                if (y == -1) {
1565                    y = url.length();
1566                }
1567
1568                String ppid = url.substring(x + 3, y);
1569
1570                if (Validator.isNotNull(ppid)) {
1571                    friendlyURL = url.substring(0, x);
1572
1573                    Map<String, String[]> actualParams = null;
1574
1575                    if (params != null) {
1576                        actualParams = new HashMap<String, String[]>(params);
1577                    }
1578                    else {
1579                        actualParams = new HashMap<String, String[]>();
1580                    }
1581
1582                    actualParams.put("p_p_id", new String[] {ppid});
1583                    actualParams.put("p_p_lifecycle", new String[] {"0"});
1584                    actualParams.put(
1585                        "p_p_state",
1586                        new String[] {WindowState.MAXIMIZED.toString()});
1587                    actualParams.put(
1588                        "p_p_mode", new String[] {PortletMode.VIEW.toString()});
1589
1590                    queryString =
1591                        StringPool.AMPERSAND +
1592                            HttpUtil.parameterMapToString(actualParams, false);
1593                }
1594            }
1595        }
1596
1597        friendlyURL = StringUtil.replace(
1598            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
1599
1600        if (friendlyURL.endsWith(StringPool.SLASH)) {
1601            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
1602        }
1603
1604        Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1605            groupId, privateLayout, friendlyURL);
1606
1607        return new Object[] {layout, queryString};
1608    }
1609
1610    /**
1611     * @deprecated Use <code>getScopeGroupId</code>.
1612     */
1613    public long getPortletGroupId(long plid) {
1614        Layout layout = null;
1615
1616        try {
1617            layout = LayoutLocalServiceUtil.getLayout(plid);
1618        }
1619        catch (Exception e) {
1620        }
1621
1622        return getPortletGroupId(layout);
1623    }
1624
1625    /**
1626     * @deprecated Use <code>getScopeGroupId</code>.
1627     */
1628    public long getPortletGroupId(Layout layout) {
1629        return getScopeGroupId(layout);
1630    }
1631
1632    /**
1633     * @deprecated Use <code>getScopeGroupId</code>.
1634     */
1635    public long getPortletGroupId(HttpServletRequest request) {
1636        return getScopeGroupId(request);
1637    }
1638
1639    /**
1640     * @deprecated Use <code>getScopeGroupId</code>.
1641     */
1642    public long getPortletGroupId(ActionRequest actionRequest) {
1643        return getScopeGroupId(actionRequest);
1644    }
1645
1646    /**
1647     * @deprecated Use <code>getScopeGroupId</code>.
1648     */
1649    public long getPortletGroupId(RenderRequest renderRequest) {
1650        return getScopeGroupId(renderRequest);
1651    }
1652
1653    public String getPortletId(HttpServletRequest request) {
1654        PortletConfigImpl portletConfigImpl =
1655            (PortletConfigImpl)request.getAttribute(
1656                JavaConstants.JAVAX_PORTLET_CONFIG);
1657
1658        if (portletConfigImpl != null) {
1659            return portletConfigImpl.getPortletId();
1660        }
1661        else {
1662            return null;
1663        }
1664    }
1665
1666    public String getPortletId(PortletRequest portletRequest) {
1667        PortletConfigImpl portletConfigImpl =
1668            (PortletConfigImpl)portletRequest.getAttribute(
1669                JavaConstants.JAVAX_PORTLET_CONFIG);
1670
1671        if (portletConfigImpl != null) {
1672            return portletConfigImpl.getPortletId();
1673        }
1674        else {
1675            return null;
1676        }
1677    }
1678
1679    public String getPortletNamespace(String portletId) {
1680        StringBuilder sb = new StringBuilder();
1681
1682        sb.append(StringPool.UNDERLINE);
1683        sb.append(portletId);
1684        sb.append(StringPool.UNDERLINE);
1685
1686        return sb.toString();
1687    }
1688
1689    public String getPortletTitle(
1690        String portletId, long companyId, String languageId) {
1691
1692        Locale locale = LocaleUtil.fromLanguageId(languageId);
1693
1694        return getPortletTitle(portletId, companyId, locale);
1695    }
1696
1697    public String getPortletTitle(
1698        String portletId, long companyId, Locale locale) {
1699
1700        StringBuilder sb = new StringBuilder();
1701
1702        sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1703        sb.append(StringPool.PERIOD);
1704        sb.append(portletId);
1705
1706        return LanguageUtil.get(companyId, locale, sb.toString());
1707    }
1708
1709    public String getPortletTitle(String portletId, User user) {
1710        StringBuilder sb = new StringBuilder();
1711
1712        sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1713        sb.append(StringPool.PERIOD);
1714        sb.append(portletId);
1715
1716        return LanguageUtil.get(
1717            user.getCompanyId(), user.getLocale(), sb.toString());
1718    }
1719
1720    public String getPortletTitle(
1721        Portlet portlet, long companyId, String languageId) {
1722
1723        return getPortletTitle(portlet.getPortletId(), companyId, languageId);
1724    }
1725
1726    public String getPortletTitle(
1727        Portlet portlet, long companyId, Locale locale) {
1728
1729        return getPortletTitle(portlet.getPortletId(), companyId, locale);
1730    }
1731
1732    public String getPortletTitle(Portlet portlet, User user) {
1733        return getPortletTitle(portlet.getPortletId(), user);
1734    }
1735
1736    public String getPortletTitle(
1737        Portlet portlet, ServletContext servletContext, Locale locale) {
1738
1739        PortletConfig portletConfig = PortletConfigFactory.create(
1740            portlet, servletContext);
1741
1742        ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
1743
1744        return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
1745    }
1746
1747    public String getPortletXmlFileName() throws SystemException {
1748        if (PrefsPropsUtil.getBoolean(
1749                PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
1750                PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
1751
1752            return PORTLET_XML_FILE_NAME_CUSTOM;
1753        }
1754        else {
1755            return PORTLET_XML_FILE_NAME_STANDARD;
1756        }
1757    }
1758
1759    public PortletPreferences getPreferences(HttpServletRequest request) {
1760        RenderRequest renderRequest = (RenderRequest)request.getAttribute(
1761            JavaConstants.JAVAX_PORTLET_REQUEST);
1762
1763        PortletPreferences preferences = null;
1764
1765        if (renderRequest != null) {
1766            PortletPreferencesWrapper preferencesWrapper =
1767                (PortletPreferencesWrapper)renderRequest.getPreferences();
1768
1769            preferences = preferencesWrapper.getPreferencesImpl();
1770        }
1771
1772        return preferences;
1773    }
1774
1775    public PreferencesValidator getPreferencesValidator(Portlet portlet) {
1776        PortletApp portletApp = portlet.getPortletApp();
1777
1778        if (portletApp.isWARFile()) {
1779            PortletBag portletBag = PortletBagPool.get(
1780                portlet.getRootPortletId());
1781
1782            return portletBag.getPreferencesValidatorInstance();
1783        }
1784        else {
1785            PreferencesValidator preferencesValidator = null;
1786
1787            if (Validator.isNotNull(portlet.getPreferencesValidator())) {
1788                preferencesValidator =
1789                    (PreferencesValidator)InstancePool.get(
1790                        portlet.getPreferencesValidator());
1791            }
1792
1793            return preferencesValidator;
1794        }
1795    }
1796
1797    public long getScopeGroupId(long plid) {
1798        Layout layout = null;
1799
1800        try {
1801            layout = LayoutLocalServiceUtil.getLayout(plid);
1802        }
1803        catch (Exception e) {
1804        }
1805
1806        return getScopeGroupId(layout);
1807    }
1808
1809    public long getScopeGroupId(Layout layout) {
1810        if (layout == null) {
1811            return 0;
1812        }
1813        else {
1814            return layout.getGroupId();
1815        }
1816    }
1817
1818    public long getScopeGroupId(Layout layout, String portletId) {
1819        if (layout == null) {
1820            return 0;
1821        }
1822        else {
1823            if (Validator.isNotNull(portletId)) {
1824                try {
1825                    PortletPreferences portletSetup =
1826                        PortletPreferencesFactoryUtil.getLayoutPortletSetup(
1827                            layout, portletId);
1828
1829                    long scopeLayoutId = GetterUtil.getLong(
1830                        portletSetup.getValue("lfr-scope-layout-id", null));
1831
1832                    if (scopeLayoutId > 0) {
1833                        Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
1834                            layout.getGroupId(), layout.isPrivateLayout(),
1835                            scopeLayoutId);
1836
1837                        return scopeLayout.getScopeGroup().getGroupId();
1838                    }
1839                }
1840                catch (Exception e) {
1841                }
1842            }
1843
1844            return layout.getGroupId();
1845        }
1846    }
1847
1848    public long getScopeGroupId(HttpServletRequest request) {
1849        String portletId = getPortletId(request);
1850
1851        return getScopeGroupId(request, portletId);
1852    }
1853
1854    public long getScopeGroupId(HttpServletRequest request, String portletId) {
1855        Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
1856
1857        long scopeGroupId = 0;
1858
1859        if (layout != null) {
1860            Group group = layout.getGroup();
1861
1862            if (group.getName().equals(GroupConstants.CONTROL_PANEL)) {
1863                long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
1864
1865                if (doAsGroupId <= 0) {
1866                    try {
1867                        Group guestGroup = GroupLocalServiceUtil.getGroup(
1868                            group.getCompanyId(), GroupConstants.GUEST);
1869
1870                        doAsGroupId = guestGroup.getGroupId();
1871                    }
1872                    catch (Exception e) {
1873                    }
1874                }
1875
1876                if (doAsGroupId > 0) {
1877                    scopeGroupId = doAsGroupId;
1878                }
1879            }
1880        }
1881
1882        if (scopeGroupId <= 0) {
1883            scopeGroupId = getScopeGroupId(layout, portletId);
1884        }
1885
1886        return scopeGroupId;
1887    }
1888
1889    public long getScopeGroupId(PortletRequest portletRequest) {
1890        return getScopeGroupId(getHttpServletRequest(portletRequest));
1891    }
1892
1893    public User getSelectedUser(HttpServletRequest request)
1894        throws PortalException, SystemException {
1895
1896        return getSelectedUser(request, true);
1897    }
1898
1899    public User getSelectedUser(
1900            HttpServletRequest request, boolean checkPermission)
1901        throws PortalException, SystemException {
1902
1903        long userId = ParamUtil.getLong(request, "p_u_i_d");
1904
1905        User user = null;
1906
1907        try {
1908            if (checkPermission) {
1909                user = UserServiceUtil.getUserById(userId);
1910            }
1911            else {
1912                user = UserLocalServiceUtil.getUserById(userId);
1913            }
1914        }
1915        catch (NoSuchUserException nsue) {
1916        }
1917
1918        return user;
1919    }
1920
1921    public User getSelectedUser(PortletRequest portletRequest)
1922        throws PortalException, SystemException {
1923
1924        return getSelectedUser(portletRequest, true);
1925    }
1926
1927    public User getSelectedUser(
1928            PortletRequest portletRequest, boolean checkPermission)
1929        throws PortalException, SystemException {
1930
1931        return getSelectedUser(
1932            getHttpServletRequest(portletRequest), checkPermission);
1933    }
1934
1935    public String getStaticResourceURL(
1936        HttpServletRequest request, String uri) {
1937
1938        return getStaticResourceURL(request, uri, null, 0);
1939    }
1940
1941    public String getStaticResourceURL(
1942        HttpServletRequest request, String uri, String queryString) {
1943
1944        return getStaticResourceURL(request, uri, queryString, 0);
1945    }
1946
1947    public String getStaticResourceURL(
1948        HttpServletRequest request, String uri, long timestamp) {
1949
1950        return getStaticResourceURL(request, uri, null, timestamp);
1951    }
1952
1953    public String getStaticResourceURL(
1954        HttpServletRequest request, String uri, String queryString,
1955        long timestamp) {
1956
1957        ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1958            WebKeys.THEME_DISPLAY);
1959
1960        Theme theme = themeDisplay.getTheme();
1961        ColorScheme colorScheme = themeDisplay.getColorScheme();
1962
1963        Map<String, String[]> parameterMap = null;
1964
1965        if (Validator.isNotNull(queryString)) {
1966            parameterMap = HttpUtil.getParameterMap(queryString);
1967        }
1968
1969        StringBuilder sb = new StringBuilder();
1970
1971        // URI
1972
1973        sb.append(uri);
1974        sb.append(StringPool.QUESTION);
1975
1976        // Browser id
1977
1978        if ((parameterMap == null) ||
1979            (!parameterMap.containsKey("browserId"))) {
1980
1981            sb.append("&browserId=");
1982            sb.append(BrowserSnifferUtil.getBrowserId(request));
1983        }
1984
1985        // Theme and color scheme
1986
1987        if (uri.endsWith(".jsp")) {
1988            if ((parameterMap == null) ||
1989                (!parameterMap.containsKey("themeId"))) {
1990
1991                sb.append("&themeId=");
1992                sb.append(theme.getThemeId());
1993            }
1994
1995            if ((parameterMap == null) ||
1996                (!parameterMap.containsKey("colorSchemeId"))) {
1997
1998                sb.append("&colorSchemeId=");
1999                sb.append(colorScheme.getColorSchemeId());
2000            }
2001        }
2002
2003        // Minifier
2004
2005        if (themeDisplay.isThemeCssFastLoad()) {
2006            if ((parameterMap == null) ||
2007                (!parameterMap.containsKey("minifierType"))) {
2008
2009                String minifierType = "js";
2010
2011                if (uri.endsWith(".css") || uri.endsWith("css.jsp")) {
2012                    minifierType = "css";
2013                }
2014
2015                sb.append("&minifierType=");
2016                sb.append(minifierType);
2017            }
2018        }
2019
2020        // Query string
2021
2022        if (Validator.isNotNull(queryString)) {
2023            if (!queryString.startsWith(StringPool.AMPERSAND)) {
2024                sb.append(StringPool.AMPERSAND);
2025            }
2026
2027            sb.append(queryString);
2028        }
2029
2030        // Timestamp
2031
2032        if ((parameterMap == null) || (!parameterMap.containsKey("t"))) {
2033            sb.append("&t=");
2034            sb.append(theme.getTimestamp());
2035        }
2036
2037        String url = sb.toString();
2038
2039        url = StringUtil.replace(url, "?&", StringPool.QUESTION);
2040
2041        return url;
2042    }
2043
2044    public String getStrutsAction(HttpServletRequest request) {
2045        String strutsAction = ParamUtil.getString(request, "struts_action");
2046
2047        if (Validator.isNotNull(strutsAction)) {
2048
2049            // This method should only return a Struts action if you're dealing
2050            // with a regular HTTP servlet request, not a portlet HTTP servlet
2051            // request.
2052
2053            return StringPool.BLANK;
2054        }
2055
2056        return _getPortletParam(request, "struts_action");
2057    }
2058
2059    public String[] getSystemCommunityRoles() {
2060        return _allSystemCommunityRoles;
2061    }
2062
2063    public String[] getSystemGroups() {
2064        return _allSystemGroups;
2065    }
2066
2067    public String[] getSystemOrganizationRoles() {
2068        return _allSystemOrganizationRoles;
2069    }
2070
2071    public String[] getSystemRoles() {
2072        return _allSystemRoles;
2073    }
2074
2075    public String[] getTagsCategories(PortletRequest portletRequest) {
2076        return TagsUtil.getTagsCategories(portletRequest);
2077    }
2078
2079    public String[] getTagsEntries(PortletRequest portletRequest) {
2080        return TagsUtil.getTagsEntries(portletRequest);
2081    }
2082
2083    public UploadPortletRequest getUploadPortletRequest(
2084        ActionRequest actionRequest) {
2085
2086        if (actionRequest instanceof ActionRequestImpl) {
2087            ActionRequestImpl actionRequestImpl =
2088                (ActionRequestImpl)actionRequest;
2089
2090            DynamicServletRequest dynamicRequest =
2091                (DynamicServletRequest)
2092                actionRequestImpl.getHttpServletRequest();
2093
2094             HttpServletRequestWrapper requestWrapper =
2095                 (HttpServletRequestWrapper)dynamicRequest.getRequest();
2096
2097            UploadServletRequest uploadRequest = getUploadServletRequest(
2098                requestWrapper);
2099
2100            return new UploadPortletRequestImpl(
2101                uploadRequest,
2102                PortalUtil.getPortletNamespace(
2103                actionRequestImpl.getPortletName()));
2104
2105        }
2106        else {
2107
2108            com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl
2109                actionRequestImpl =
2110                (com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl)
2111                actionRequest;
2112
2113            HttpServletRequestWrapper requestWrapper =
2114                (HttpServletRequestWrapper)
2115                actionRequestImpl.getHttpServletRequest();
2116
2117            UploadServletRequest uploadRequest = getUploadServletRequest(
2118                requestWrapper);
2119
2120            String portletWindowName = (String)actionRequest.getAttribute(
2121                "javax.portlet.portletc.portletWindowName");
2122
2123            return new UploadPortletRequestImpl(
2124                uploadRequest,
2125                PortalUtil.getPortletNamespace(portletWindowName));
2126        }
2127
2128    }
2129
2130    public UploadServletRequest getUploadServletRequest(
2131        HttpServletRequest request) {
2132
2133        HttpServletRequestWrapper requestWrapper = null;
2134
2135        if (request instanceof HttpServletRequestWrapper) {
2136            requestWrapper = (HttpServletRequestWrapper)request;
2137        }
2138
2139        UploadServletRequest uploadRequest = null;
2140
2141        while (uploadRequest == null) {
2142
2143            // Find the underlying UploadServletRequest wrapper. For example,
2144            // WebSphere wraps all requests with ProtectedServletRequest.
2145
2146            if (requestWrapper instanceof UploadServletRequest) {
2147                uploadRequest = (UploadServletRequest)requestWrapper;
2148            }
2149            else {
2150                HttpServletRequest parentRequest =
2151                    (HttpServletRequest)requestWrapper.getRequest();
2152
2153                if (!(parentRequest instanceof HttpServletRequestWrapper)) {
2154
2155                    // This block should never be reached unless this method is
2156                    // called from a hot deployable portlet. See LayoutAction.
2157
2158                    uploadRequest = new UploadServletRequestImpl(parentRequest);
2159
2160                    break;
2161                }
2162                else {
2163                    requestWrapper = (HttpServletRequestWrapper)parentRequest;
2164                }
2165            }
2166        }
2167
2168        return uploadRequest;
2169    }
2170
2171    public Date getUptime() {
2172        return UP_TIME;
2173    }
2174
2175    public String getURLWithSessionId(String url, String sessionId) {
2176        if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
2177            return url;
2178        }
2179
2180        // LEP-4787
2181
2182        int x = url.indexOf(StringPool.SEMICOLON);
2183
2184        if (x != -1) {
2185            return url;
2186        }
2187
2188        x = url.indexOf(StringPool.QUESTION);
2189
2190        if (x != -1) {
2191            StringBuilder sb = new StringBuilder();
2192
2193            sb.append(url.substring(0, x));
2194            sb.append(_JSESSIONID);
2195            sb.append(sessionId);
2196            sb.append(url.substring(x));
2197
2198            return sb.toString();
2199        }
2200
2201        // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
2202        // http://www.abc.com/;jsessionid=XYZ does work.
2203
2204        x = url.indexOf(StringPool.DOUBLE_SLASH);
2205
2206        StringBuilder sb = new StringBuilder();
2207
2208        sb.append(url);
2209
2210        if (x != -1) {
2211            int y = url.lastIndexOf(StringPool.SLASH);
2212
2213            if (x + 1 == y) {
2214                sb.append(StringPool.SLASH);
2215            }
2216        }
2217
2218        sb.append(_JSESSIONID);
2219        sb.append(sessionId);
2220
2221        return sb.toString();
2222    }
2223
2224    public User getUser(HttpServletRequest request)
2225        throws PortalException, SystemException {
2226
2227        long userId = getUserId(request);
2228
2229        if (userId <= 0) {
2230
2231            // Portlet WARs may have the correct remote user and not have the
2232            // correct user id because the user id is saved in the session
2233            // and may not be accessible by the portlet WAR's session. This
2234            // behavior is inconsistent across different application servers.
2235
2236            String remoteUser = request.getRemoteUser();
2237
2238            if (remoteUser == null) {
2239                return null;
2240            }
2241
2242            userId = GetterUtil.getLong(remoteUser);
2243        }
2244
2245        User user = (User)request.getAttribute(WebKeys.USER);
2246
2247        if (user == null) {
2248            user = UserLocalServiceUtil.getUserById(userId);
2249
2250            request.setAttribute(WebKeys.USER, user);
2251        }
2252
2253        return user;
2254    }
2255
2256    public User getUser(PortletRequest portletRequest)
2257        throws PortalException, SystemException {
2258
2259        return getUser(getHttpServletRequest(portletRequest));
2260    }
2261
2262    public long getUserId(HttpServletRequest request) {
2263        Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
2264
2265        if (userIdObj != null) {
2266            return userIdObj.longValue();
2267        }
2268
2269        String path = GetterUtil.getString(request.getPathInfo());
2270        String strutsAction = getStrutsAction(request);
2271        String actionName = _getPortletParam(request, "actionName");
2272
2273        boolean alwaysAllowDoAsUser = false;
2274
2275        if (path.equals("/portal/fckeditor") ||
2276            strutsAction.equals("/document_library/edit_file_entry") ||
2277            strutsAction.equals("/image_gallery/edit_image") ||
2278            strutsAction.equals("/wiki/edit_page_attachment") ||
2279            actionName.equals("addFile")) {
2280
2281            alwaysAllowDoAsUser = true;
2282        }
2283
2284        if ((!PropsValues.PORTAL_JAAS_ENABLE &&
2285              PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
2286            (alwaysAllowDoAsUser)) {
2287
2288            String doAsUserIdString = ParamUtil.getString(
2289                request, "doAsUserId");
2290
2291            try {
2292                long doAsUserId = getDoAsUserId(
2293                    request, doAsUserIdString, alwaysAllowDoAsUser);
2294
2295                if (doAsUserId > 0) {
2296                    if (_log.isDebugEnabled()) {
2297                        _log.debug("Impersonating user " + doAsUserId);
2298                    }
2299
2300                    return doAsUserId;
2301                }
2302            }
2303            catch (Exception e) {
2304                _log.error("Unable to impersonate user " + doAsUserIdString, e);
2305            }
2306        }
2307
2308        HttpSession session = request.getSession();
2309
2310        userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
2311
2312        if (userIdObj != null) {
2313            request.setAttribute(WebKeys.USER_ID, userIdObj);
2314
2315            return userIdObj.longValue();
2316        }
2317        else {
2318            return 0;
2319        }
2320    }
2321
2322    public long getUserId(PortletRequest portletRequest) {
2323        return getUserId(getHttpServletRequest(portletRequest));
2324    }
2325
2326    public String getUserName(long userId, String defaultUserName) {
2327        return getUserName(
2328            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
2329    }
2330
2331    public String getUserName(
2332        long userId, String defaultUserName, String userAttribute) {
2333
2334        return getUserName(userId, defaultUserName, userAttribute, null);
2335    }
2336
2337    public String getUserName(
2338        long userId, String defaultUserName, HttpServletRequest request) {
2339
2340        return getUserName(
2341            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
2342    }
2343
2344    public String getUserName(
2345        long userId, String defaultUserName, String userAttribute,
2346        HttpServletRequest request) {
2347
2348        String userName = defaultUserName;
2349
2350        try {
2351            User user = UserLocalServiceUtil.getUserById(userId);
2352
2353            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
2354                userName = user.getFullName();
2355            }
2356            else {
2357                userName = user.getScreenName();
2358            }
2359
2360            if (request != null) {
2361                Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2362
2363                PortletURL portletURL = new PortletURLImpl(
2364                    request, PortletKeys.DIRECTORY, layout.getPlid(),
2365                    PortletRequest.RENDER_PHASE);
2366
2367                portletURL.setWindowState(WindowState.MAXIMIZED);
2368                portletURL.setPortletMode(PortletMode.VIEW);
2369
2370                portletURL.setParameter(
2371                    "struts_action", "/directory/view_user");
2372                portletURL.setParameter(
2373                    "p_u_i_d", String.valueOf(user.getUserId()));
2374
2375                userName =
2376                    "<a href=\"" + portletURL.toString() + "\">" + userName +
2377                        "</a>";
2378            }
2379        }
2380        catch (Exception e) {
2381        }
2382
2383        return userName;
2384    }
2385
2386    public String getUserPassword(HttpSession session) {
2387        return (String)session.getAttribute(WebKeys.USER_PASSWORD);
2388    }
2389
2390    public String getUserPassword(HttpServletRequest request) {
2391        HttpSession session = request.getSession();
2392
2393        return getUserPassword(session);
2394    }
2395
2396    public String getUserPassword(PortletRequest portletRequest) {
2397        return getUserPassword(getHttpServletRequest(portletRequest));
2398    }
2399
2400    public String getUserValue(long userId, String param, String defaultValue)
2401        throws SystemException {
2402
2403        if (Validator.isNotNull(defaultValue)) {
2404            return defaultValue;
2405        }
2406        else {
2407            try {
2408                User user = UserLocalServiceUtil.getUserById(userId);
2409
2410                return BeanPropertiesUtil.getString(user, param, defaultValue);
2411            }
2412            catch (PortalException pe) {
2413                return StringPool.BLANK;
2414            }
2415        }
2416    }
2417
2418    public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay) {
2419        String layoutURL = getLayoutURL(themeDisplay);
2420
2421        Layout layout = themeDisplay.getLayout();
2422
2423        StringBuilder sb = new StringBuilder();
2424
2425        if (HttpUtil.hasDomain(layoutURL)) {
2426            String protocol = HttpUtil.getProtocol(layoutURL);
2427            String domain = HttpUtil.getDomain(layoutURL);
2428            HttpUtil.removeDomain(layoutURL);
2429
2430            sb.append(protocol);
2431            sb.append(Http.PROTOCOL_DELIMITER);
2432            sb.append(domain);
2433
2434            if (Validator.isNotNull(_pathContext)) {
2435                sb.append(_pathContext);
2436            }
2437
2438            if (themeDisplay.isI18n()) {
2439                sb.append(StringPool.SLASH);
2440                sb.append(themeDisplay.getI18nLanguageId());
2441            }
2442
2443            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2444            sb.append(layout.getFriendlyURL());
2445        }
2446        else {
2447            sb.append(themeDisplay.getPortalURL());
2448
2449            if (Validator.isNotNull(_pathContext)) {
2450                sb.append(_pathContext);
2451            }
2452
2453            if (themeDisplay.isI18n()) {
2454                sb.append(StringPool.SLASH);
2455                sb.append(themeDisplay.getI18nLanguageId());
2456            }
2457
2458            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2459
2460            Group group = layout.getGroup();
2461
2462            if (layout.isPrivateLayout()) {
2463                if (group.isUser()) {
2464                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
2465                }
2466                else {
2467                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
2468                }
2469            }
2470            else {
2471                sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
2472            }
2473
2474            sb.append(group.getFriendlyURL());
2475            sb.append(layout.getFriendlyURL());
2476        }
2477
2478        sb.append("/-/");
2479
2480        FriendlyURLMapper friendlyURLMapper =
2481            portlet.getFriendlyURLMapperInstance();
2482
2483        if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
2484            sb.append(friendlyURLMapper.getMapping());
2485        }
2486        else {
2487            sb.append(portlet.getPortletId());
2488        }
2489
2490        return sb.toString();
2491    }
2492
2493    public boolean isLayoutFirstPageable(String type) {
2494        return GetterUtil.getBoolean(
2495            PropsUtil.get(PropsKeys.LAYOUT_FIRST_PAGEABLE, new Filter(type)),
2496            false);
2497    }
2498
2499    public boolean isLayoutFriendliable(Layout layout) {
2500        return GetterUtil.getBoolean(
2501            PropsUtil.get(
2502                PropsKeys.LAYOUT_URL_FRIENDLIABLE,
2503                new Filter(layout.getType())),
2504            true);
2505    }
2506
2507    public boolean isLayoutParentable(Layout layout) {
2508        return isLayoutParentable(layout.getType());
2509    }
2510
2511    public boolean isLayoutParentable(String type) {
2512        return GetterUtil.getBoolean(
2513            PropsUtil.get(PropsKeys.LAYOUT_PARENTABLE, new Filter(type)), true);
2514    }
2515
2516    public boolean isLayoutSitemapable(Layout layout) {
2517        if (layout.isPrivateLayout()) {
2518            return false;
2519        }
2520
2521        return GetterUtil.getBoolean(PropsUtil.get(
2522            PropsKeys.LAYOUT_SITEMAPABLE, new Filter(layout.getType())), true);
2523    }
2524
2525    public boolean isMethodGet(PortletRequest portletRequest) {
2526        HttpServletRequest request = getHttpServletRequest(portletRequest);
2527
2528        String method = GetterUtil.getString(request.getMethod());
2529
2530        if (method.equalsIgnoreCase(HttpMethods.GET)) {
2531            return true;
2532        }
2533        else {
2534            return false;
2535        }
2536    }
2537
2538    public boolean isMethodPost(PortletRequest portletRequest) {
2539        HttpServletRequest request = getHttpServletRequest(portletRequest);
2540
2541        String method = GetterUtil.getString(request.getMethod());
2542
2543        if (method.equalsIgnoreCase(HttpMethods.POST)) {
2544            return true;
2545        }
2546        else {
2547            return false;
2548        }
2549    }
2550
2551    public boolean isReservedParameter(String name) {
2552        return _reservedParams.contains(name);
2553    }
2554
2555    public boolean isSystemGroup(String groupName) {
2556        if (groupName == null) {
2557            return false;
2558        }
2559
2560        groupName = groupName.trim();
2561
2562        int pos = Arrays.binarySearch(
2563            _sortedSystemGroups, groupName, new StringComparator());
2564
2565        if (pos >= 0) {
2566            return true;
2567        }
2568        else {
2569            return false;
2570        }
2571    }
2572
2573    public boolean isSystemRole(String roleName) {
2574        if (roleName == null) {
2575            return false;
2576        }
2577
2578        roleName = roleName.trim();
2579
2580        int pos = Arrays.binarySearch(
2581            _sortedSystemRoles, roleName, new StringComparator());
2582
2583        if (pos >= 0) {
2584            return true;
2585        }
2586        else {
2587            pos = Arrays.binarySearch(
2588                _sortedSystemCommunityRoles, roleName, new StringComparator());
2589
2590            if (pos >= 0) {
2591                return true;
2592            }
2593            else {
2594                pos = Arrays.binarySearch(
2595                    _sortedSystemOrganizationRoles, roleName,
2596                    new StringComparator());
2597
2598                if (pos >= 0) {
2599                    return true;
2600                }
2601            }
2602        }
2603
2604        return false;
2605    }
2606
2607    public boolean isUpdateAvailable()
2608        throws PortalException, SystemException {
2609
2610        return PluginPackageUtil.isUpdateAvailable();
2611    }
2612
2613    public void renderPage(
2614            StringBuilder sb, ServletContext servletContext,
2615            HttpServletRequest request, HttpServletResponse response,
2616            String path)
2617        throws IOException, ServletException {
2618
2619        RequestDispatcher requestDispatcher =
2620            servletContext.getRequestDispatcher(path);
2621
2622        StringServletResponse stringResponse = new StringServletResponse(
2623            response);
2624
2625        requestDispatcher.include(request, stringResponse);
2626
2627        sb.append(stringResponse.getString());
2628    }
2629
2630    public void renderPortlet(
2631            StringBuilder sb, ServletContext servletContext,
2632            HttpServletRequest request, HttpServletResponse response,
2633            Portlet portlet, String queryString)
2634        throws IOException, ServletException {
2635
2636        renderPortlet(
2637            sb, servletContext, request, response, portlet, queryString, null,
2638            null, null);
2639    }
2640
2641    public void renderPortlet(
2642            StringBuilder sb, ServletContext servletContext,
2643            HttpServletRequest request, HttpServletResponse response,
2644            Portlet portlet, String queryString, String columnId,
2645            Integer columnPos, Integer columnCount)
2646        throws IOException, ServletException {
2647
2648        renderPortlet(
2649            sb, servletContext, request, response, portlet, queryString,
2650            columnId, columnPos, columnCount, null);
2651    }
2652
2653    public void renderPortlet(
2654            StringBuilder sb, ServletContext servletContext,
2655            HttpServletRequest request, HttpServletResponse response,
2656            Portlet portlet, String queryString, String columnId,
2657            Integer columnPos, Integer columnCount, String path)
2658        throws IOException, ServletException {
2659
2660        queryString = GetterUtil.getString(queryString);
2661        columnId = GetterUtil.getString(columnId);
2662
2663        if (columnPos == null) {
2664            columnPos = new Integer(0);
2665        }
2666
2667        if (columnCount == null) {
2668            columnCount = new Integer(0);
2669        }
2670
2671        request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
2672        request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
2673        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
2674        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
2675        request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
2676
2677        if (path == null) {
2678            path = "/html/portal/render_portlet.jsp";
2679        }
2680
2681        RequestDispatcher requestDispatcher =
2682            servletContext.getRequestDispatcher(path);
2683
2684        if (sb != null) {
2685            StringServletResponse stringResponse = new StringServletResponse(
2686                response);
2687
2688            requestDispatcher.include(request, stringResponse);
2689
2690            boolean showPortlet = true;
2691
2692            Boolean portletConfiguratorVisibility =
2693                (Boolean)request.getAttribute(
2694                    WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
2695
2696            if (portletConfiguratorVisibility != null) {
2697                ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2698                    WebKeys.THEME_DISPLAY);
2699
2700                try {
2701                    if (!PortletPermissionUtil.contains(
2702                            themeDisplay.getPermissionChecker(),
2703                            portlet.getPortletId(), ActionKeys.CONFIGURATION)) {
2704
2705                        showPortlet = false;
2706                    }
2707                }
2708                catch (Exception e) {
2709                    throw new ServletException(e);
2710                }
2711
2712                request.removeAttribute(
2713                    WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
2714            }
2715
2716            if (showPortlet) {
2717                sb.append(stringResponse.getString());
2718            }
2719        }
2720        else {
2721
2722            // LEP-766
2723
2724            response.setContentType(ContentTypes.TEXT_HTML_UTF8);
2725
2726            requestDispatcher.include(request, response);
2727        }
2728    }
2729
2730    public void sendError(
2731            Exception e, HttpServletRequest request,
2732            HttpServletResponse response)
2733        throws IOException, ServletException {
2734
2735        sendError(0, e, request, response);
2736    }
2737
2738    public void sendError(
2739            int status, Exception e, HttpServletRequest request,
2740            HttpServletResponse response)
2741        throws IOException, ServletException {
2742
2743        if (status == 0) {
2744            if (e instanceof PrincipalException) {
2745                status = HttpServletResponse.SC_FORBIDDEN;
2746            }
2747            else {
2748                String name = e.getClass().getName();
2749
2750                name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
2751
2752                if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
2753                    status = HttpServletResponse.SC_NOT_FOUND;
2754                }
2755            }
2756
2757            if (status == 0) {
2758                status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
2759            }
2760        }
2761
2762        HttpSession session = request.getSession();
2763
2764        ServletContext servletContext = session.getServletContext();
2765
2766        String redirect = PATH_MAIN + "/portal/status";
2767
2768        if (e instanceof NoSuchLayoutException &&
2769            Validator.isNotNull(
2770                PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
2771
2772            response.setStatus(status);
2773
2774            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
2775
2776            RequestDispatcher requestDispatcher =
2777                servletContext.getRequestDispatcher(redirect);
2778
2779            if (requestDispatcher != null) {
2780                requestDispatcher.forward(request, response);
2781            }
2782        }
2783        else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
2784            response.setStatus(status);
2785
2786            SessionErrors.add(request, e.getClass().getName(), e);
2787
2788            RequestDispatcher requestDispatcher =
2789                servletContext.getRequestDispatcher(redirect);
2790
2791            if (requestDispatcher != null) {
2792                requestDispatcher.forward(request, response);
2793            }
2794        }
2795        else {
2796            if (e != null) {
2797                response.sendError(status, e.getMessage());
2798            }
2799            else {
2800                response.sendError(status);
2801            }
2802        }
2803    }
2804
2805    public void sendError(
2806            Exception e, ActionRequest actionRequest,
2807            ActionResponse actionResponse)
2808        throws IOException {
2809
2810        sendError(0, e, actionRequest, actionResponse);
2811    }
2812
2813    public void sendError(
2814            int status, Exception e, ActionRequest actionRequest,
2815            ActionResponse actionResponse)
2816        throws IOException {
2817
2818        StringBuilder sb = new StringBuilder();
2819
2820        sb.append(_pathMain);
2821        sb.append("/portal/status?status=");
2822        sb.append(status);
2823        sb.append("&exception=");
2824        sb.append(e.getClass().getName());
2825        sb.append("&previousURL=");
2826        sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
2827
2828        actionResponse.sendRedirect(sb.toString());
2829    }
2830
2831    /**
2832     * Sets the subtitle for a page. This is just a hint and can be overridden
2833     * by subsequent calls. The last call to this method wins.
2834     *
2835     * @param       subtitle the subtitle for a page
2836     * @param       request the HTTP servlet request
2837     */
2838    public void setPageSubtitle(String subtitle, HttpServletRequest request) {
2839        request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
2840    }
2841
2842    /**
2843     * Sets the whole title for a page. This is just a hint and can be
2844     * overridden by subsequent calls. The last call to this method wins.
2845     *
2846     * @param       title the whole title for a page
2847     * @param       request the HTTP servlet request
2848     */
2849    public void setPageTitle(String title, HttpServletRequest request) {
2850        request.setAttribute(WebKeys.PAGE_TITLE, title);
2851    }
2852
2853    /**
2854     * Sets the port obtained on the first request to the portal.
2855     *
2856     * @param       request the HTTP servlet request
2857     */
2858    public void setPortalPort(HttpServletRequest request) {
2859        if (_portalPort.intValue() == -1) {
2860            synchronized (_portalPort) {
2861                _portalPort = new Integer(request.getServerPort());
2862            }
2863        }
2864    }
2865
2866    public void storePreferences(PortletPreferences preferences)
2867        throws IOException, ValidatorException {
2868
2869        PortletPreferencesWrapper preferencesWrapper =
2870            (PortletPreferencesWrapper)preferences;
2871
2872        PortletPreferencesImpl preferencesImpl =
2873            preferencesWrapper.getPreferencesImpl();
2874
2875        preferencesImpl.store();
2876    }
2877
2878    public String transformCustomSQL(String sql) {
2879        if ((_customSqlClassNames == null) ||
2880            (_customSqlClassNameIds == null)) {
2881
2882            _initCustomSQL();
2883        }
2884
2885        return StringUtil.replace(
2886            sql, _customSqlClassNames, _customSqlClassNameIds);
2887    }
2888
2889    public PortletMode updatePortletMode(
2890        String portletId, User user, Layout layout, PortletMode portletMode,
2891        HttpServletRequest request) {
2892
2893        LayoutTypePortlet layoutType =
2894            (LayoutTypePortlet)layout.getLayoutType();
2895
2896        if (portletMode == null || Validator.isNull(portletMode.toString())) {
2897            if (layoutType.hasModeAboutPortletId(portletId)) {
2898                return LiferayPortletMode.ABOUT;
2899            }
2900            else if (layoutType.hasModeConfigPortletId(portletId)) {
2901                return LiferayPortletMode.CONFIG;
2902            }
2903            else if (layoutType.hasModeEditPortletId(portletId)) {
2904                return PortletMode.EDIT;
2905            }
2906            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
2907                return LiferayPortletMode.EDIT_DEFAULTS;
2908            }
2909            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
2910                return LiferayPortletMode.EDIT_GUEST;
2911            }
2912            else if (layoutType.hasModeHelpPortletId(portletId)) {
2913                return PortletMode.HELP;
2914            }
2915            else if (layoutType.hasModePreviewPortletId(portletId)) {
2916                return LiferayPortletMode.PREVIEW;
2917            }
2918            else if (layoutType.hasModePrintPortletId(portletId)) {
2919                return LiferayPortletMode.PRINT;
2920            }
2921            else {
2922                return PortletMode.VIEW;
2923            }
2924        }
2925        else {
2926            boolean updateLayout = false;
2927
2928            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
2929                !layoutType.hasModeAboutPortletId(portletId)) {
2930
2931                layoutType.addModeAboutPortletId(portletId);
2932
2933                updateLayout = true;
2934            }
2935            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
2936                     !layoutType.hasModeConfigPortletId(portletId)) {
2937
2938                layoutType.addModeConfigPortletId(portletId);
2939
2940                updateLayout = true;
2941            }
2942            else if (portletMode.equals(PortletMode.EDIT) &&
2943                     !layoutType.hasModeEditPortletId(portletId)) {
2944
2945                layoutType.addModeEditPortletId(portletId);
2946
2947                updateLayout = true;
2948            }
2949            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
2950                     !layoutType.hasModeEditDefaultsPortletId(portletId)) {
2951
2952                layoutType.addModeEditDefaultsPortletId(portletId);
2953
2954                updateLayout = true;
2955            }
2956            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
2957                     !layoutType.hasModeEditGuestPortletId(portletId)) {
2958
2959                layoutType.addModeEditGuestPortletId(portletId);
2960
2961                updateLayout = true;
2962            }
2963            else if (portletMode.equals(PortletMode.HELP) &&
2964                     !layoutType.hasModeHelpPortletId(portletId)) {
2965
2966                layoutType.addModeHelpPortletId(portletId);
2967
2968                updateLayout = true;
2969            }
2970            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
2971                     !layoutType.hasModePreviewPortletId(portletId)) {
2972
2973                layoutType.addModePreviewPortletId(portletId);
2974
2975                updateLayout = true;
2976            }
2977            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
2978                     !layoutType.hasModePrintPortletId(portletId)) {
2979
2980                layoutType.addModePrintPortletId(portletId);
2981
2982                updateLayout = true;
2983            }
2984            else if (portletMode.equals(PortletMode.VIEW) &&
2985                     !layoutType.hasModeViewPortletId(portletId)) {
2986
2987                layoutType.removeModesPortletId(portletId);
2988
2989                updateLayout = true;
2990            }
2991
2992            if (updateLayout) {
2993                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
2994
2995                if (layoutClone != null) {
2996                    layoutClone.update(
2997                        request, layout.getPlid(), layout.getTypeSettings());
2998                }
2999            }
3000
3001            return portletMode;
3002        }
3003    }
3004
3005    public WindowState updateWindowState(
3006        String portletId, User user, Layout layout, WindowState windowState,
3007        HttpServletRequest request) {
3008
3009        LayoutTypePortlet layoutType =
3010            (LayoutTypePortlet)layout.getLayoutType();
3011
3012        if ((windowState == null) ||
3013            (Validator.isNull(windowState.toString()))) {
3014
3015            if (layoutType.hasStateMaxPortletId(portletId)) {
3016                return WindowState.MAXIMIZED;
3017            }
3018            else if (layoutType.hasStateMinPortletId(portletId)) {
3019                return WindowState.MINIMIZED;
3020            }
3021            else {
3022                return WindowState.NORMAL;
3023            }
3024        }
3025        else {
3026            boolean updateLayout = false;
3027
3028            if (windowState.equals(WindowState.MAXIMIZED) &&
3029                !layoutType.hasStateMaxPortletId(portletId)) {
3030
3031                layoutType.addStateMaxPortletId(portletId);
3032
3033                updateLayout = false;
3034            }
3035            else if (windowState.equals(WindowState.MINIMIZED) &&
3036                     !layoutType.hasStateMinPortletId(portletId)) {
3037
3038                layoutType.addStateMinPortletId(portletId);
3039
3040                updateLayout = true;
3041            }
3042            else if (windowState.equals(WindowState.NORMAL) &&
3043                     !layoutType.hasStateNormalPortletId(portletId)) {
3044
3045                layoutType.removeStatesPortletId(portletId);
3046
3047                updateLayout = true;
3048            }
3049
3050            if (updateLayout) {
3051                LayoutClone layoutClone = LayoutCloneFactory.getInstance();
3052
3053                if (layoutClone != null) {
3054                    layoutClone.update(
3055                        request, layout.getPlid(), layout.getTypeSettings());
3056                }
3057            }
3058
3059            return windowState;
3060        }
3061    }
3062
3063    protected long getDoAsUserId(
3064            HttpServletRequest request, String doAsUserIdString,
3065            boolean alwaysAllowDoAsUser)
3066        throws Exception {
3067
3068        if (Validator.isNull(doAsUserIdString)) {
3069            return 0;
3070        }
3071
3072        long doAsUserId = 0;
3073
3074        try {
3075            Company company = getCompany(request);
3076
3077            doAsUserId = GetterUtil.getLong(
3078                Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
3079        }
3080        catch (Exception e) {
3081            if (_log.isWarnEnabled()) {
3082                _log.warn(
3083                    "Unable to impersonate " + doAsUserIdString +
3084                        " because the string cannot be decrypted",
3085                    e);
3086            }
3087
3088            return 0;
3089        }
3090
3091        if (_log.isDebugEnabled()) {
3092            if (alwaysAllowDoAsUser) {
3093                _log.debug(
3094                    "doAsUserId path or Struts action is always allowed");
3095            }
3096            else {
3097                _log.debug(
3098                    "doAsUserId path is Struts action not always allowed");
3099            }
3100        }
3101
3102        if (alwaysAllowDoAsUser) {
3103            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
3104
3105            return doAsUserId;
3106        }
3107
3108        HttpSession session = request.getSession();
3109
3110        Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
3111
3112        if (realUserIdObj == null) {
3113            return 0;
3114        }
3115
3116        User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
3117
3118        long[] organizationIds = doAsUser.getOrganizationIds();
3119
3120        User realUser = UserLocalServiceUtil.getUserById(
3121            realUserIdObj.longValue());
3122        boolean checkGuest = true;
3123
3124        PermissionChecker permissionChecker =
3125            PermissionCheckerFactoryUtil.create(realUser, checkGuest);
3126
3127        if (doAsUser.isDefaultUser() ||
3128            UserPermissionUtil.contains(
3129                permissionChecker, doAsUserId, organizationIds,
3130                ActionKeys.IMPERSONATE)) {
3131
3132            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
3133
3134            return doAsUserId;
3135        }
3136        else {
3137            _log.error(
3138                "User " + realUserIdObj + " does not have the permission " +
3139                    "to impersonate " + doAsUserId);
3140
3141            return 0;
3142        }
3143    }
3144
3145    private String _getCurrentURL(HttpServletRequest request) {
3146        StringBuilder sb = new StringBuilder();
3147
3148        StringBuffer requestURL = request.getRequestURL();
3149
3150        if (requestURL != null) {
3151            sb.append(requestURL.toString());
3152        }
3153
3154        String queryString = request.getQueryString();
3155
3156        if (Validator.isNull(queryString)) {
3157            return sb.toString();
3158        }
3159
3160        String portletId = request.getParameter("p_p_id");
3161
3162        String redirectParam = "redirect";
3163
3164        if (Validator.isNotNull(portletId)) {
3165            redirectParam = getPortletNamespace(portletId) + redirectParam;
3166        }
3167
3168        Map<String, String[]> parameterMap = HttpUtil.parameterMapFromString(
3169            queryString);
3170
3171        String[] redirectValues = parameterMap.get(redirectParam);
3172
3173        if ((redirectValues != null) && (redirectValues.length > 0)) {
3174
3175            // Prevent the redirect for GET requests from growing indefinitely
3176            // and using up all the available space by remembering only the
3177            // first redirect.
3178
3179            String redirect = HttpUtil.decodeURL(
3180                GetterUtil.getString(redirectValues[0]));
3181
3182            int pos = redirect.indexOf(StringPool.QUESTION);
3183
3184            if (pos != -1) {
3185                String subqueryString = redirect.substring(
3186                    pos + 1, redirect.length());
3187
3188                Map<String, String[]> subparameterMap =
3189                    HttpUtil.parameterMapFromString(subqueryString);
3190
3191                String[] subredirectValues = subparameterMap.get(redirectParam);
3192
3193                if ((subredirectValues != null) &&
3194                    (subredirectValues.length > 0)) {
3195
3196                    String subredirect = HttpUtil.decodeURL(
3197                        GetterUtil.getString(subredirectValues[0]));
3198
3199                    parameterMap.put(redirectParam, new String[] {subredirect});
3200
3201                    queryString = HttpUtil.parameterMapToString(
3202                        parameterMap, false);
3203                }
3204            }
3205        }
3206
3207        sb.append(StringPool.QUESTION);
3208        sb.append(queryString);
3209
3210        return sb.toString();
3211    }
3212
3213    private long _getPlidFromPortletId(
3214        long groupId, boolean privateLayout, String portletId) {
3215
3216        long plid = LayoutConstants.DEFAULT_PLID;
3217
3218        try {
3219            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3220                groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
3221
3222            for (Layout layout : layouts) {
3223                LayoutTypePortlet layoutTypePortlet =
3224                    (LayoutTypePortlet)layout.getLayoutType();
3225
3226                if (layoutTypePortlet.hasPortletId(portletId)) {
3227                    if (getScopeGroupId(layout, portletId) == groupId) {
3228                        plid = layout.getPlid();
3229
3230                        break;
3231                    }
3232                }
3233            }
3234        }
3235        catch (SystemException se) {
3236            if (_log.isWarnEnabled()) {
3237                _log.warn(se.getMessage());
3238            }
3239        }
3240
3241        return plid;
3242    }
3243
3244    private String _getPortletParam(HttpServletRequest request, String name) {
3245        String value = null;
3246
3247        int valueCount = 0;
3248
3249        Enumeration<String> enu = request.getParameterNames();
3250
3251        while (enu.hasMoreElements()) {
3252            String curName = enu.nextElement();
3253
3254            int pos = curName.indexOf(StringPool.UNDERLINE + name);
3255
3256            if (pos != -1) {
3257                valueCount++;
3258
3259                // There should never be more than one value
3260
3261                if (valueCount > 1) {
3262                    return StringPool.BLANK;
3263                }
3264
3265                String curValue = ParamUtil.getString(request, curName);
3266
3267                if (Validator.isNotNull(curValue)) {
3268
3269                    // The Struts action must be for the correct portlet
3270
3271                    String portletId1 = curName.substring(1, pos);
3272                    String portletId2 = ParamUtil.getString(request, "p_p_id");
3273
3274                    if (portletId1.equals(portletId2)) {
3275                        value = curValue;
3276                    }
3277                }
3278            }
3279        }
3280
3281        if (value == null) {
3282            value = StringPool.BLANK;
3283        }
3284
3285        return value;
3286    }
3287
3288    private void _initCustomSQL() {
3289        _customSqlClassNames = new String[] {
3290            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
3291            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
3292            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
3293            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
3294            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
3295                "BOOKMARKSENTRY$]",
3296            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
3297                "DLFILEENTRY$]",
3298            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
3299            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
3300                "MBMESSAGE$]",
3301            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
3302            "[$FALSE$]",
3303            "[$TRUE$]"
3304        };
3305
3306        DBUtil dbUtil = DBUtil.getInstance();
3307
3308        _customSqlClassNameIds = new String[] {
3309            String.valueOf(PortalUtil.getClassNameId(Organization.class)),
3310            String.valueOf(PortalUtil.getClassNameId(User.class)),
3311            String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
3312            String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
3313            String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
3314            String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
3315            String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
3316            String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
3317            String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
3318            dbUtil.getTemplateFalse(),
3319            dbUtil.getTemplateTrue()
3320        };
3321    }
3322
3323    private static final String _JSESSIONID = ";jsessionid=";
3324
3325    private static final String _LOCALHOST = "localhost";
3326
3327    private static final String  _PRIVATE_GROUP_SERVLET_MAPPING =
3328        PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
3329
3330    private static final String _PRIVATE_USER_SERVLET_MAPPING =
3331        PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
3332
3333    private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
3334        PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
3335
3336    private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
3337
3338    private String _computerAddress;
3339    private String _computerName;
3340    private String _portalLibDir;
3341    private String _portalWebDir;
3342    private String _cdnHost;
3343    private String _pathContext;
3344    private String _pathFriendlyURLPrivateGroup;
3345    private String _pathFriendlyURLPrivateUser;
3346    private String _pathFriendlyURLPublic;
3347    private String _pathImage;
3348    private String _pathMain;
3349    private Integer _portalPort = new Integer(-1);
3350    private String[] _allSystemCommunityRoles;
3351    private String[] _allSystemGroups;
3352    private String[] _allSystemOrganizationRoles;
3353    private String[] _allSystemRoles;
3354    private String[] _sortedSystemCommunityRoles;
3355    private String[] _sortedSystemGroups;
3356    private String[] _sortedSystemOrganizationRoles;
3357    private String[] _sortedSystemRoles;
3358    private Set<String> _reservedParams;
3359    private String[] _customSqlClassNames = null;
3360    private String[] _customSqlClassNameIds = null;
3361    private Map<String, Long> _plidToPortletIdCache =
3362        new ConcurrentHashMap<String, Long>();
3363
3364}