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