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