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