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