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