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