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