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