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