001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.util;
016    
017    import com.liferay.portal.NoSuchCompanyException;
018    import com.liferay.portal.NoSuchImageException;
019    import com.liferay.portal.NoSuchLayoutException;
020    import com.liferay.portal.NoSuchResourceException;
021    import com.liferay.portal.NoSuchUserException;
022    import com.liferay.portal.cluster.ClusterInvokeThreadLocal;
023    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
024    import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
025    import com.liferay.portal.kernel.cluster.ClusterRequest;
026    import com.liferay.portal.kernel.dao.db.DB;
027    import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
028    import com.liferay.portal.kernel.exception.PortalException;
029    import com.liferay.portal.kernel.exception.SystemException;
030    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
031    import com.liferay.portal.kernel.language.LanguageUtil;
032    import com.liferay.portal.kernel.log.Log;
033    import com.liferay.portal.kernel.log.LogFactoryUtil;
034    import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
035    import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
036    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
037    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
038    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
039    import com.liferay.portal.kernel.portlet.LiferayWindowState;
040    import com.liferay.portal.kernel.portlet.PortletBag;
041    import com.liferay.portal.kernel.portlet.PortletBagPool;
042    import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
043    import com.liferay.portal.kernel.servlet.FileTimestampUtil;
044    import com.liferay.portal.kernel.servlet.HttpHeaders;
045    import com.liferay.portal.kernel.servlet.HttpMethods;
046    import com.liferay.portal.kernel.servlet.PipingServletResponse;
047    import com.liferay.portal.kernel.servlet.SessionErrors;
048    import com.liferay.portal.kernel.servlet.StringServletResponse;
049    import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
050    import com.liferay.portal.kernel.upload.UploadPortletRequest;
051    import com.liferay.portal.kernel.upload.UploadServletRequest;
052    import com.liferay.portal.kernel.util.ArrayUtil;
053    import com.liferay.portal.kernel.util.Base64;
054    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
055    import com.liferay.portal.kernel.util.CharPool;
056    import com.liferay.portal.kernel.util.ContentTypes;
057    import com.liferay.portal.kernel.util.ContextPathUtil;
058    import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
059    import com.liferay.portal.kernel.util.GetterUtil;
060    import com.liferay.portal.kernel.util.HtmlUtil;
061    import com.liferay.portal.kernel.util.Http;
062    import com.liferay.portal.kernel.util.HttpUtil;
063    import com.liferay.portal.kernel.util.InheritableMap;
064    import com.liferay.portal.kernel.util.JavaConstants;
065    import com.liferay.portal.kernel.util.ListUtil;
066    import com.liferay.portal.kernel.util.LocaleUtil;
067    import com.liferay.portal.kernel.util.MethodHandler;
068    import com.liferay.portal.kernel.util.MethodKey;
069    import com.liferay.portal.kernel.util.ParamUtil;
070    import com.liferay.portal.kernel.util.PropsKeys;
071    import com.liferay.portal.kernel.util.ReleaseInfo;
072    import com.liferay.portal.kernel.util.SetUtil;
073    import com.liferay.portal.kernel.util.StringBundler;
074    import com.liferay.portal.kernel.util.StringComparator;
075    import com.liferay.portal.kernel.util.StringPool;
076    import com.liferay.portal.kernel.util.StringUtil;
077    import com.liferay.portal.kernel.util.Time;
078    import com.liferay.portal.kernel.util.UnicodeProperties;
079    import com.liferay.portal.kernel.util.Validator;
080    import com.liferay.portal.kernel.xml.QName;
081    import com.liferay.portal.model.BaseModel;
082    import com.liferay.portal.model.ClassName;
083    import com.liferay.portal.model.ColorScheme;
084    import com.liferay.portal.model.Company;
085    import com.liferay.portal.model.Group;
086    import com.liferay.portal.model.GroupConstants;
087    import com.liferay.portal.model.Layout;
088    import com.liferay.portal.model.LayoutConstants;
089    import com.liferay.portal.model.LayoutSet;
090    import com.liferay.portal.model.LayoutType;
091    import com.liferay.portal.model.LayoutTypePortlet;
092    import com.liferay.portal.model.LayoutTypePortletConstants;
093    import com.liferay.portal.model.Organization;
094    import com.liferay.portal.model.Portlet;
095    import com.liferay.portal.model.PublicRenderParameter;
096    import com.liferay.portal.model.Resource;
097    import com.liferay.portal.model.ResourceCode;
098    import com.liferay.portal.model.ResourceConstants;
099    import com.liferay.portal.model.ResourcePermission;
100    import com.liferay.portal.model.Role;
101    import com.liferay.portal.model.RoleConstants;
102    import com.liferay.portal.model.Theme;
103    import com.liferay.portal.model.Ticket;
104    import com.liferay.portal.model.TicketConstants;
105    import com.liferay.portal.model.User;
106    import com.liferay.portal.model.UserGroup;
107    import com.liferay.portal.model.VirtualLayoutConstants;
108    import com.liferay.portal.model.impl.LayoutTypePortletImpl;
109    import com.liferay.portal.model.impl.VirtualLayout;
110    import com.liferay.portal.plugin.PluginPackageUtil;
111    import com.liferay.portal.security.auth.AuthException;
112    import com.liferay.portal.security.auth.AuthTokenUtil;
113    import com.liferay.portal.security.auth.CompanyThreadLocal;
114    import com.liferay.portal.security.auth.PrincipalException;
115    import com.liferay.portal.security.permission.ActionKeys;
116    import com.liferay.portal.security.permission.PermissionChecker;
117    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
118    import com.liferay.portal.security.permission.ResourceActionsUtil;
119    import com.liferay.portal.service.ClassNameLocalServiceUtil;
120    import com.liferay.portal.service.CompanyLocalServiceUtil;
121    import com.liferay.portal.service.GroupLocalServiceUtil;
122    import com.liferay.portal.service.GroupServiceUtil;
123    import com.liferay.portal.service.LayoutLocalServiceUtil;
124    import com.liferay.portal.service.LayoutSetLocalServiceUtil;
125    import com.liferay.portal.service.PortletLocalServiceUtil;
126    import com.liferay.portal.service.ResourceCodeLocalServiceUtil;
127    import com.liferay.portal.service.ResourceLocalServiceUtil;
128    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
129    import com.liferay.portal.service.TicketLocalServiceUtil;
130    import com.liferay.portal.service.UserLocalServiceUtil;
131    import com.liferay.portal.service.UserServiceUtil;
132    import com.liferay.portal.service.permission.GroupPermissionUtil;
133    import com.liferay.portal.service.permission.LayoutPermissionUtil;
134    import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
135    import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
136    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
137    import com.liferay.portal.service.permission.PortletPermissionUtil;
138    import com.liferay.portal.service.permission.UserPermissionUtil;
139    import com.liferay.portal.servlet.filters.i18n.I18nFilter;
140    import com.liferay.portal.servlet.filters.secure.NonceUtil;
141    import com.liferay.portal.struts.StrutsUtil;
142    import com.liferay.portal.theme.ThemeDisplay;
143    import com.liferay.portal.upload.UploadPortletRequestImpl;
144    import com.liferay.portal.upload.UploadServletRequestImpl;
145    import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
146    import com.liferay.portal.webserver.WebServerServlet;
147    import com.liferay.portlet.ActionResponseImpl;
148    import com.liferay.portlet.ControlPanelEntry;
149    import com.liferay.portlet.DefaultControlPanelEntryFactory;
150    import com.liferay.portlet.PortletConfigFactoryUtil;
151    import com.liferay.portlet.PortletConfigImpl;
152    import com.liferay.portlet.PortletContextImpl;
153    import com.liferay.portlet.PortletPreferencesFactoryUtil;
154    import com.liferay.portlet.PortletPreferencesImpl;
155    import com.liferay.portlet.PortletPreferencesThreadLocal;
156    import com.liferay.portlet.PortletPreferencesWrapper;
157    import com.liferay.portlet.PortletQNameUtil;
158    import com.liferay.portlet.PortletRequestImpl;
159    import com.liferay.portlet.PortletResponseImpl;
160    import com.liferay.portlet.PortletURLFactoryUtil;
161    import com.liferay.portlet.PortletURLImpl;
162    import com.liferay.portlet.RenderRequestImpl;
163    import com.liferay.portlet.RenderResponseImpl;
164    import com.liferay.portlet.StateAwareResponseImpl;
165    import com.liferay.portlet.UserAttributes;
166    import com.liferay.portlet.admin.util.OmniadminUtil;
167    import com.liferay.portlet.asset.model.AssetTag;
168    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
169    import com.liferay.portlet.blogs.model.BlogsEntry;
170    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
171    import com.liferay.portlet.calendar.model.CalEvent;
172    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
173    import com.liferay.portlet.expando.ValueDataException;
174    import com.liferay.portlet.expando.model.ExpandoBridge;
175    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
176    import com.liferay.portlet.journal.asset.JournalArticleAssetRendererFactory;
177    import com.liferay.portlet.journal.model.JournalArticle;
178    import com.liferay.portlet.journal.model.JournalArticleConstants;
179    import com.liferay.portlet.journal.service.JournalArticleLocalServiceUtil;
180    import com.liferay.portlet.login.util.LoginUtil;
181    import com.liferay.portlet.messageboards.model.MBMessage;
182    import com.liferay.portlet.messageboards.model.MBThread;
183    import com.liferay.portlet.social.model.SocialRelationConstants;
184    import com.liferay.portlet.social.util.FacebookUtil;
185    import com.liferay.portlet.wiki.model.WikiPage;
186    import com.liferay.util.Encryptor;
187    import com.liferay.util.JS;
188    import com.liferay.util.PwdGenerator;
189    import com.liferay.util.UniqueList;
190    import com.liferay.util.servlet.DynamicServletRequest;
191    
192    import java.io.IOException;
193    import java.io.Serializable;
194    
195    import java.lang.reflect.Method;
196    
197    import java.net.InetAddress;
198    import java.net.UnknownHostException;
199    
200    import java.util.ArrayList;
201    import java.util.Arrays;
202    import java.util.Calendar;
203    import java.util.Collection;
204    import java.util.Collections;
205    import java.util.Date;
206    import java.util.Enumeration;
207    import java.util.HashMap;
208    import java.util.HashSet;
209    import java.util.Iterator;
210    import java.util.List;
211    import java.util.Locale;
212    import java.util.Map;
213    import java.util.Properties;
214    import java.util.ResourceBundle;
215    import java.util.Set;
216    import java.util.TimeZone;
217    import java.util.TreeSet;
218    import java.util.concurrent.ConcurrentHashMap;
219    import java.util.concurrent.atomic.AtomicInteger;
220    import java.util.regex.Matcher;
221    import java.util.regex.Pattern;
222    
223    import javax.portlet.ActionRequest;
224    import javax.portlet.ActionResponse;
225    import javax.portlet.PortletConfig;
226    import javax.portlet.PortletMode;
227    import javax.portlet.PortletPreferences;
228    import javax.portlet.PortletRequest;
229    import javax.portlet.PortletResponse;
230    import javax.portlet.PortletURL;
231    import javax.portlet.PreferencesValidator;
232    import javax.portlet.RenderRequest;
233    import javax.portlet.RenderResponse;
234    import javax.portlet.ValidatorException;
235    import javax.portlet.WindowState;
236    
237    import javax.servlet.RequestDispatcher;
238    import javax.servlet.ServletContext;
239    import javax.servlet.ServletException;
240    import javax.servlet.http.HttpServletRequest;
241    import javax.servlet.http.HttpServletRequestWrapper;
242    import javax.servlet.http.HttpServletResponse;
243    import javax.servlet.http.HttpSession;
244    import javax.servlet.jsp.PageContext;
245    
246    import org.apache.struts.Globals;
247    
248    /**
249     * @author Brian Wing Shun Chan
250     * @author Brian Myunghun Kim
251     * @author Jorge Ferrer
252     * @author Raymond Augé
253     * @author Eduardo Lundgren
254     * @author Wesley Gong
255     * @author Hugo Huijser
256     * @author Juan Fernández
257     */
258    public class PortalImpl implements Portal {
259    
260            public PortalImpl() {
261    
262                    // Computer name
263    
264                    _computerName = System.getProperty("env.COMPUTERNAME");
265    
266                    if (Validator.isNull(_computerName)) {
267                            _computerName = System.getProperty("env.HOST");
268                    }
269    
270                    if (Validator.isNull(_computerName)) {
271                            _computerName = System.getProperty("env.HOSTNAME");
272                    }
273    
274                    if (Validator.isNull(_computerName)) {
275                            try {
276                                    _computerName = InetAddress.getLocalHost().getHostName();
277                            }
278                            catch (UnknownHostException uhe) {
279                            }
280                    }
281    
282                    try {
283                            _computerAddress = InetAddress.getByName(
284                                    _computerName).getHostAddress();
285                    }
286                    catch (UnknownHostException uhe) {
287                    }
288    
289                    if (Validator.isNull(_computerAddress)) {
290                            try {
291                                    _computerAddress = InetAddress.getLocalHost().getHostAddress();
292                            }
293                            catch (UnknownHostException uhe) {
294                            }
295                    }
296    
297                    // Paths
298    
299                    _pathProxy = PropsValues.PORTAL_PROXY_PATH;
300    
301                    _pathContext = ContextPathUtil.getContextPath(PropsValues.PORTAL_CTX);
302                    _pathContext = _pathProxy.concat(_pathContext);
303    
304                    _pathFriendlyURLPrivateGroup =
305                            _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
306                    _pathFriendlyURLPrivateUser =
307                            _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
308                    _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
309                    _pathImage = _pathContext + PATH_IMAGE;
310                    _pathMain = _pathContext + PATH_MAIN;
311    
312                    // Groups
313    
314                    String[] customSystemGroups = PropsUtil.getArray(
315                            PropsKeys.SYSTEM_GROUPS);
316    
317                    if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
318                            _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
319                    }
320                    else {
321                            _allSystemGroups = ArrayUtil.append(
322                                    GroupConstants.SYSTEM_GROUPS, customSystemGroups);
323                    }
324    
325                    _sortedSystemGroups = new String[_allSystemGroups.length];
326    
327                    System.arraycopy(
328                            _allSystemGroups, 0, _sortedSystemGroups, 0,
329                            _allSystemGroups.length);
330    
331                    Arrays.sort(_sortedSystemGroups, new StringComparator());
332    
333                    // Regular roles
334    
335                    String[] customSystemRoles = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
336    
337                    if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
338                            _allSystemRoles = RoleConstants.SYSTEM_ROLES;
339                    }
340                    else {
341                            _allSystemRoles = ArrayUtil.append(
342                                    RoleConstants.SYSTEM_ROLES, customSystemRoles);
343                    }
344    
345                    _sortedSystemRoles = new String[_allSystemRoles.length];
346    
347                    System.arraycopy(
348                            _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
349    
350                    Arrays.sort(_sortedSystemRoles, new StringComparator());
351    
352                    // Organization roles
353    
354                    String[] customSystemOrganizationRoles = PropsUtil.getArray(
355                            PropsKeys.SYSTEM_ORGANIZATION_ROLES);
356    
357                    if ((customSystemOrganizationRoles == null) ||
358                            (customSystemOrganizationRoles.length == 0)) {
359    
360                            _allSystemOrganizationRoles =
361                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES;
362                    }
363                    else {
364                            _allSystemOrganizationRoles = ArrayUtil.append(
365                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES,
366                                    customSystemOrganizationRoles);
367                    }
368    
369                    _sortedSystemOrganizationRoles =
370                            new String[_allSystemOrganizationRoles.length];
371    
372                    System.arraycopy(
373                            _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
374                            _allSystemOrganizationRoles.length);
375    
376                    Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
377    
378                    // Site roles
379    
380                    String[] customSystemSiteRoles = PropsUtil.getArray(
381                            PropsKeys.SYSTEM_SITE_ROLES);
382    
383                    if ((customSystemSiteRoles == null) ||
384                            (customSystemSiteRoles.length == 0)) {
385    
386                            _allSystemSiteRoles = RoleConstants.SYSTEM_SITE_ROLES;
387                    }
388                    else {
389                            _allSystemSiteRoles = ArrayUtil.append(
390                                    RoleConstants.SYSTEM_SITE_ROLES, customSystemSiteRoles);
391                    }
392    
393                    _sortedSystemSiteRoles = new String[_allSystemSiteRoles.length];
394    
395                    System.arraycopy(
396                            _allSystemSiteRoles, 0, _sortedSystemSiteRoles, 0,
397                            _allSystemSiteRoles.length);
398    
399                    Arrays.sort(_sortedSystemSiteRoles, new StringComparator());
400    
401                    // Authentication token ignore actions and tokens
402    
403                    _authTokenIgnoreActions = SetUtil.fromArray(
404                            PropsValues.AUTH_TOKEN_IGNORE_ACTIONS);
405                    _authTokenIgnorePortlets = SetUtil.fromArray(
406                            PropsValues.AUTH_TOKEN_IGNORE_PORTLETS);
407    
408                    // Portlet add default resource check white list
409    
410                    resetPortletAddDefaultResourceCheckWhitelist();
411                    resetPortletAddDefaultResourceCheckWhitelistActions();
412    
413                    // Reserved parameter names
414    
415                    _reservedParams = new HashSet<String>();
416    
417                    // Portal authentication
418    
419                    _reservedParams.add("p_auth");
420                    _reservedParams.add("p_auth_secret");
421    
422                    // Portal layout
423    
424                    _reservedParams.add("p_l_id");
425                    _reservedParams.add("p_l_reset");
426    
427                    // Portal portlet
428    
429                    _reservedParams.add("p_p_auth");
430                    _reservedParams.add("p_p_id");
431                    _reservedParams.add("p_p_i_id");
432                    _reservedParams.add("p_p_lifecycle");
433                    _reservedParams.add("p_p_url_type");
434                    _reservedParams.add("p_p_state");
435                    _reservedParams.add("p_p_state_rcv"); // LPS-14144
436                    _reservedParams.add("p_p_mode");
437                    _reservedParams.add("p_p_resource_id");
438                    _reservedParams.add("p_p_cacheability");
439                    _reservedParams.add("p_p_width");
440                    _reservedParams.add("p_p_col_id");
441                    _reservedParams.add("p_p_col_pos");
442                    _reservedParams.add("p_p_col_count");
443                    _reservedParams.add("p_p_static");
444                    _reservedParams.add("p_p_isolated");
445    
446                    // Portal theme
447    
448                    _reservedParams.add("p_t_lifecycle"); // LPS-14383
449    
450                    // Portal virtual layout
451    
452                    _reservedParams.add("p_v_l_s_g_id"); // LPS-23010
453    
454                    // Portal outer portlet
455    
456                    _reservedParams.add("p_o_p_id"); // LPS-12097
457    
458                    // Portal fragment
459    
460                    _reservedParams.add("p_f_id");
461    
462                    // Portal journal article
463    
464                    _reservedParams.add("p_j_a_id"); // LPS-16418
465    
466                    // Miscellaneous
467    
468                    _reservedParams.add("saveLastPath");
469                    _reservedParams.add("scroll");
470            }
471    
472            public void addPageDescription(
473                    String description, HttpServletRequest request) {
474    
475                    String requestDescription = (String)request.getAttribute(
476                            WebKeys.PAGE_DESCRIPTION);
477    
478                    if (requestDescription != null) {
479                            description = requestDescription + StringPool.SPACE + description;
480                    }
481    
482                    request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
483            }
484    
485            public void addPageKeywords(String keywords, HttpServletRequest request) {
486                    List<String> requestKeywords = (List<String>)request.getAttribute(
487                            WebKeys.PAGE_KEYWORDS);
488    
489                    if (requestKeywords == null) {
490                            requestKeywords = new UniqueList<String>();
491                    }
492    
493                    String[] keywordsArray = StringUtil.split(keywords);
494    
495                    for (String keyword : keywordsArray) {
496                            if (!requestKeywords.contains(keyword.toLowerCase())) {
497                                    requestKeywords.add(keyword.toLowerCase());
498                            }
499                    }
500    
501                    request.setAttribute(WebKeys.PAGE_KEYWORDS, requestKeywords);
502            }
503    
504            public void addPageSubtitle(String subtitle, HttpServletRequest request) {
505                    String requestSubtitle = (String)request.getAttribute(
506                            WebKeys.PAGE_SUBTITLE);
507    
508                    if (requestSubtitle != null) {
509                            subtitle = requestSubtitle + StringPool.SPACE + subtitle;
510                    }
511    
512                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
513            }
514    
515            public void addPageTitle(String title, HttpServletRequest request) {
516                    String requestTitle = (String)request.getAttribute(WebKeys.PAGE_TITLE);
517    
518                    if (requestTitle != null) {
519                            title = requestTitle + StringPool.SPACE + title;
520                    }
521    
522                    request.setAttribute(WebKeys.PAGE_TITLE, title);
523            }
524    
525            public void addPortalPortEventListener(
526                    PortalPortEventListener portalPortEventListener) {
527    
528                    if (!_portalPortEventListeners.contains(portalPortEventListener)) {
529                            _portalPortEventListeners.add(portalPortEventListener);
530                    }
531            }
532    
533            public void addPortletBreadcrumbEntry(
534                    HttpServletRequest request, String title, String url) {
535    
536                    addPortletBreadcrumbEntry(request, title, url, null);
537            }
538    
539            public void addPortletBreadcrumbEntry(
540                    HttpServletRequest request, String title, String url,
541                    Map<String, Object> data) {
542    
543                    List<BreadcrumbEntry> breadcrumbEntries =
544                            (List<BreadcrumbEntry>)request.getAttribute(
545                                    WebKeys.PORTLET_BREADCRUMBS);
546    
547                    if (breadcrumbEntries == null) {
548                            breadcrumbEntries = new ArrayList<BreadcrumbEntry>();
549    
550                            request.setAttribute(
551                                    WebKeys.PORTLET_BREADCRUMBS, breadcrumbEntries);
552                    }
553    
554                    BreadcrumbEntry breadcrumbEntry = new BreadcrumbEntry();
555    
556                    breadcrumbEntry.setData(data);
557                    breadcrumbEntry.setTitle(title);
558                    breadcrumbEntry.setURL(url);
559    
560                    breadcrumbEntries.add(breadcrumbEntry);
561            }
562    
563            public void addPortletDefaultResource(
564                            HttpServletRequest request, Portlet portlet)
565                    throws PortalException, SystemException {
566    
567                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
568                            WebKeys.THEME_DISPLAY);
569    
570                    Layout layout = themeDisplay.getLayout();
571    
572                    addDefaultResource(themeDisplay, layout, portlet, true);
573                    addDefaultResource(themeDisplay, layout, portlet, false);
574            }
575    
576            public void addPortletDefaultResource(
577                            long companyId, Layout layout, Portlet portlet)
578                    throws PortalException, SystemException {
579    
580                    addDefaultResource(companyId, layout, portlet, true);
581                    addDefaultResource(companyId, layout, portlet, false);
582            }
583    
584            public String addPreservedParameters(
585                    ThemeDisplay themeDisplay, Layout layout, String url,
586                    boolean doAsUser) {
587    
588                    if (doAsUser) {
589                            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
590                                    url = HttpUtil.addParameter(
591                                            url, "doAsUserId", themeDisplay.getDoAsUserId());
592                            }
593    
594                            if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
595                                    url = HttpUtil.addParameter(
596                                            url, "doAsUserLanguageId",
597                                            themeDisplay.getDoAsUserLanguageId());
598                            }
599                    }
600    
601                    if (layout.isTypeControlPanel()) {
602                            if (themeDisplay.getDoAsGroupId() > 0) {
603                                    url = HttpUtil.addParameter(
604                                            url, "doAsGroupId", themeDisplay.getDoAsGroupId());
605                            }
606    
607                            if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
608                                    url = HttpUtil.addParameter(
609                                            url, "refererPlid", themeDisplay.getRefererPlid());
610                            }
611    
612                            if (Validator.isNotNull(themeDisplay.getControlPanelCategory())) {
613                                    url = HttpUtil.addParameter(
614                                            url, "controlPanelCategory",
615                                            themeDisplay.getControlPanelCategory());
616                            }
617                    }
618    
619                    return url;
620            }
621    
622            public String addPreservedParameters(
623                    ThemeDisplay themeDisplay, String url) {
624    
625                    return addPreservedParameters(
626                            themeDisplay, themeDisplay.getLayout(), url, true);
627            }
628    
629            public void clearRequestParameters(RenderRequest renderRequest) {
630                    RenderRequestImpl renderRequestImpl = (RenderRequestImpl)renderRequest;
631    
632                    if (renderRequestImpl.isTriggeredByActionURL()) {
633                            Map<String, String[]> renderParameters =
634                                    renderRequestImpl.getRenderParameters();
635    
636                            renderParameters.clear();
637                    }
638            }
639    
640            public void copyRequestParameters(
641                    ActionRequest actionRequest, ActionResponse actionResponse) {
642    
643                    if (actionResponse instanceof StateAwareResponseImpl) {
644                            StateAwareResponseImpl stateAwareResponseImpl =
645                                    (StateAwareResponseImpl)actionResponse;
646    
647                            if (stateAwareResponseImpl.getRedirectLocation() != null) {
648                                    if (_log.isDebugEnabled()) {
649                                            _log.debug(
650                                                    "Cannot copy parameters on a redirected " +
651                                                            "StateAwareResponseImpl");
652                                    }
653    
654                                    return;
655                            }
656                    }
657    
658                    ActionResponseImpl actionResponseImpl =
659                            (ActionResponseImpl)actionResponse;
660    
661                    Map<String, String[]> renderParameters =
662                            actionResponseImpl.getRenderParameterMap();
663    
664                    actionResponse.setRenderParameter("p_p_lifecycle", "1");
665    
666                    Enumeration<String> enu = actionRequest.getParameterNames();
667    
668                    while (enu.hasMoreElements()) {
669                            String param = enu.nextElement();
670                            String[] values = actionRequest.getParameterValues(param);
671    
672                            if (renderParameters.get(
673                                            actionResponseImpl.getNamespace() + param) == null) {
674    
675                                    actionResponse.setRenderParameter(param, values);
676                            }
677                    }
678            }
679    
680            public String escapeRedirect(String url) {
681                    if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
682                            return url;
683                    }
684    
685                    String domain = HttpUtil.getDomain(url);
686    
687                    int pos = -1;
688    
689                    if ((pos = domain.indexOf(CharPool.COLON)) != -1) {
690                            domain = domain.substring(0, pos);
691                    }
692    
693                    try {
694                            Company company = CompanyLocalServiceUtil.fetchCompanyByVirtualHost(
695                                    domain);
696    
697                            if (company != null) {
698                                    return url;
699                            }
700                    }
701                    catch (Exception e) {
702                    }
703    
704                    try {
705                            LayoutSet layoutSet = LayoutSetLocalServiceUtil.fetchLayoutSet(
706                                    domain);
707    
708                            if (layoutSet != null) {
709                                    return url;
710                            }
711                    }
712                    catch (Exception e) {
713                    }
714    
715                    try {
716                            String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
717    
718                            if (securityMode.equals("domain")) {
719                                    String[] allowedDomains =
720                                            PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
721    
722                                    if ((allowedDomains.length > 0) &&
723                                            !ArrayUtil.contains(allowedDomains, domain)) {
724    
725                                            if (_log.isDebugEnabled()) {
726                                                    _log.debug("Redirect URL " + url + " is not allowed");
727                                            }
728    
729                                            url = null;
730                                    }
731                            }
732                            else if (securityMode.equals("ip")) {
733                                    String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
734    
735                                    InetAddress inetAddress = InetAddress.getByName(domain);
736    
737                                    if ((allowedIps.length > 0) &&
738                                            !ArrayUtil.contains(
739                                                    allowedIps, inetAddress.getHostAddress())) {
740    
741                                            String serverIp = getComputerAddress();
742    
743                                            if (!serverIp.equals(inetAddress.getHostAddress()) ||
744                                                    !ArrayUtil.contains(allowedIps, "SERVER_IP")) {
745    
746                                                    if (_log.isDebugEnabled()) {
747                                                            _log.debug(
748                                                                    "Redirect URL " + url + " is not allowed");
749                                                    }
750    
751                                                    url = null;
752                                            }
753                                    }
754                            }
755                    }
756                    catch (UnknownHostException uhe) {
757                            if (_log.isDebugEnabled()) {
758                                    _log.debug("Unable to determine IP for redirect URL " + url);
759                            }
760    
761                            url = null;
762                    }
763    
764                    return url;
765            }
766    
767            public String generateRandomKey(HttpServletRequest request, String input) {
768                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
769                            WebKeys.THEME_DISPLAY);
770    
771                    if (themeDisplay.isLifecycleResource() ||
772                            themeDisplay.isStateExclusive()) {
773    
774                            return PwdGenerator.getPassword(PwdGenerator.KEY3, 4);
775                    }
776                    else {
777                            return DeterminateKeyGenerator.generate(input);
778                    }
779            }
780    
781            public String getActualURL(
782                            long groupId, boolean privateLayout, String mainPath,
783                            String friendlyURL, Map<String, String[]> params,
784                            Map<String, Object> requestContext)
785                    throws PortalException, SystemException {
786    
787                    String actualURL = null;
788    
789                    if (friendlyURL != null) {
790                            if (friendlyURL.startsWith(
791                                            JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
792    
793                                    try {
794                                            actualURL = getJournalArticleActualURL(
795                                                    groupId, mainPath, friendlyURL, params, requestContext);
796                                    }
797                                    catch (Exception e) {
798                                            friendlyURL = null;
799                                    }
800                            }
801                            else if (friendlyURL.startsWith(
802                                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
803    
804                                    try {
805                                            actualURL = getVirtualLayoutActualURL(
806                                                    groupId, privateLayout, mainPath, friendlyURL, params,
807                                                    requestContext);
808                                    }
809                                    catch (Exception e) {
810                                            friendlyURL = null;
811                                    }
812                            }
813                    }
814    
815                    if (actualURL == null) {
816                            actualURL = getLayoutActualURL(
817                                    groupId, privateLayout, mainPath, friendlyURL, params,
818                                    requestContext);
819                    }
820    
821                    return actualURL;
822            }
823    
824            public String getAlternateURL(
825                    HttpServletRequest request, String canonicalURL, Locale locale) {
826    
827                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
828                            WebKeys.THEME_DISPLAY);
829    
830                    LayoutSet layoutSet = themeDisplay.getLayoutSet();
831    
832                    String virtualHost = null;
833    
834                    if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
835                            virtualHost = layoutSet.getVirtualHostname();
836                    }
837                    else {
838                            Company company = themeDisplay.getCompany();
839    
840                            virtualHost = company.getVirtualHostname();
841                    }
842    
843                    String i18nPath = buildI18NPath(locale);
844    
845                    if (Validator.isNull(virtualHost)) {
846                            return canonicalURL.replaceFirst(
847                                    _PUBLIC_GROUP_SERVLET_MAPPING,
848                                    i18nPath.concat(_PUBLIC_GROUP_SERVLET_MAPPING));
849                    }
850    
851                    // www.liferay.com:8080/page to www.liferay.com:8080/es/page
852    
853                    String[] canonicalURLParts = canonicalURL.split(
854                            virtualHost.concat("(:\\d{1,5})?"), 2);
855    
856                    if ((canonicalURLParts.length > 1) &&
857                            Validator.isNotNull(canonicalURLParts[1])) {
858    
859                            int pos = canonicalURL.indexOf(
860                                    canonicalURLParts[1], canonicalURLParts[0].length());
861    
862                            return canonicalURL.substring(0, pos).concat(i18nPath).concat(
863                                    canonicalURL.substring(pos));
864                    }
865    
866                    return canonicalURL.concat(i18nPath);
867            }
868    
869            public Set<String> getAuthTokenIgnoreActions() {
870                    return _authTokenIgnoreActions;
871            }
872    
873            public Set<String> getAuthTokenIgnorePortlets() {
874                    return _authTokenIgnorePortlets;
875            }
876    
877            public BaseModel<?> getBaseModel(Resource resource)
878                    throws PortalException, SystemException {
879    
880                    ResourceCode resourceCode =
881                            ResourceCodeLocalServiceUtil.getResourceCode(resource.getCodeId());
882    
883                    String modelName = resourceCode.getName();
884                    String primKey = resource.getPrimKey();
885    
886                    return getBaseModel(modelName, primKey);
887            }
888    
889            public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
890                    throws PortalException, SystemException {
891    
892                    String modelName = resourcePermission.getName();
893                    String primKey = resourcePermission.getPrimKey();
894    
895                    return getBaseModel(modelName, primKey);
896            }
897    
898            public BaseModel<?> getBaseModel(String modelName, String primKey)
899                    throws PortalException, SystemException {
900    
901                    if (!modelName.contains(".model.")) {
902                            return null;
903                    }
904    
905                    String[] parts = StringUtil.split(modelName, CharPool.PERIOD);
906    
907                    if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
908                            return null;
909                    }
910    
911                    parts[parts.length - 2] = "service";
912    
913                    String serviceName =
914                            StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
915                    String methodName = "get" + parts[parts.length - 1];
916    
917                    Method method = null;
918    
919                    try {
920                            Class<?> serviceUtil = Class.forName(serviceName);
921    
922                            if (Validator.isNumber(primKey)) {
923                                    method = serviceUtil.getMethod(
924                                            methodName, new Class[] {Long.TYPE});
925    
926                                    return (BaseModel<?>)method.invoke(null, new Long(primKey));
927                            }
928                            else {
929                                    method = serviceUtil.getMethod(
930                                            methodName, new Class[] {String.class});
931    
932                                    return (BaseModel<?>)method.invoke(null, primKey);
933                            }
934                    }
935                    catch (Exception e) {
936                            Throwable cause = e.getCause();
937    
938                            if (cause instanceof PortalException) {
939                                    throw (PortalException)cause;
940                            }
941                            else if (cause instanceof SystemException) {
942                                    throw (SystemException)cause;
943                            }
944                            else {
945                                    throw new SystemException(cause);
946                            }
947                    }
948            }
949    
950            public long getBasicAuthUserId(HttpServletRequest request)
951                    throws PortalException, SystemException {
952    
953                    long companyId = PortalInstances.getCompanyId(request);
954    
955                    return getBasicAuthUserId(request, companyId);
956            }
957    
958            public long getBasicAuthUserId(HttpServletRequest request, long companyId)
959                    throws PortalException, SystemException {
960    
961                    long userId = 0;
962    
963                    String authorizationHeader = request.getHeader(
964                            HttpHeaders.AUTHORIZATION);
965    
966                    if (Validator.isNull(authorizationHeader)) {
967                            return userId;
968                    }
969    
970                    String[] authorizationArray = authorizationHeader.split("\\s+");
971    
972                    String authorization = authorizationArray[0];
973                    String credentials = new String(Base64.decode(authorizationArray[1]));
974    
975                    if (!authorization.equalsIgnoreCase(HttpServletRequest.BASIC_AUTH)) {
976                            return userId;
977                    }
978    
979                    String[] loginAndPassword = StringUtil.split(
980                            credentials, CharPool.COLON);
981    
982                    String login = loginAndPassword[0].trim();
983    
984                    String password = null;
985    
986                    if (loginAndPassword.length > 1) {
987                            password = loginAndPassword[1].trim();
988                    }
989    
990                    // Strip @uid and @sn for backwards compatibility
991    
992                    if (login.endsWith("@uid")) {
993                            int pos = login.indexOf("@uid");
994    
995                            login = login.substring(0, pos);
996                    }
997                    else if (login.endsWith("@sn")) {
998                            int pos = login.indexOf("@sn");
999    
1000                            login = login.substring(0, pos);
1001                    }
1002    
1003                    try {
1004                            userId = LoginUtil.getAuthenticatedUserId(
1005                                    request, login, password, null);
1006                    }
1007                    catch (AuthException ae) {
1008                    }
1009    
1010                    return userId;
1011            }
1012    
1013            public String getCanonicalURL(String completeURL, ThemeDisplay themeDisplay)
1014                    throws PortalException, SystemException {
1015    
1016                    completeURL = removeRedirectParameter(completeURL);
1017    
1018                    String parametersURL = StringPool.BLANK;
1019    
1020                    int pos = completeURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
1021    
1022                    if (pos == -1) {
1023                            pos = completeURL.indexOf(StringPool.QUESTION);
1024                    }
1025    
1026                    String groupFriendlyURL = completeURL;
1027    
1028                    if (pos != -1) {
1029                            groupFriendlyURL = completeURL.substring(0, pos);
1030    
1031                            parametersURL = completeURL.substring(pos);
1032                    }
1033    
1034                    Layout layout = themeDisplay.getLayout();
1035    
1036                    String layoutFriendlyURL = StringPool.BLANK;
1037    
1038                    if (groupFriendlyURL.contains(layout.getFriendlyURL()) && (
1039                            !layout.isFirstParent() || Validator.isNotNull(parametersURL))) {
1040    
1041                            layoutFriendlyURL = layout.getFriendlyURL();
1042                    }
1043    
1044                    Group group = layout.getGroup();
1045    
1046                    groupFriendlyURL = getGroupFriendlyURL(
1047                            group, layout.isPrivateLayout(), themeDisplay, true);
1048    
1049                    return groupFriendlyURL.concat(layoutFriendlyURL).concat(parametersURL);
1050            }
1051    
1052            /**
1053             * @deprecated {@link #getCDNHost(boolean)}
1054             */
1055            public String getCDNHost() {
1056                    long companyId = CompanyThreadLocal.getCompanyId();
1057    
1058                    return getCDNHostHttp(companyId);
1059            }
1060    
1061            public String getCDNHost(boolean secure) {
1062                    long companyId = CompanyThreadLocal.getCompanyId();
1063    
1064                    if (secure) {
1065                            return getCDNHostHttps(companyId);
1066                    }
1067                    else {
1068                            return getCDNHostHttp(companyId);
1069                    }
1070            }
1071    
1072            public String getCDNHost(HttpServletRequest request)
1073                    throws PortalException, SystemException {
1074    
1075                    String cdnHost = null;
1076    
1077                    Company company = getCompany(request);
1078    
1079                    if (request.isSecure()) {
1080                            cdnHost = getCDNHostHttps(company.getCompanyId());
1081                    }
1082                    else {
1083                            cdnHost = getCDNHostHttp(company.getCompanyId());
1084                    }
1085    
1086                    return ParamUtil.getString(request, "cdn_host", cdnHost);
1087            }
1088    
1089            public String getCDNHostHttp(long companyId) {
1090                    String cdnHostHttp = _cdnHostHttpMap.get(companyId);
1091    
1092                    if (cdnHostHttp != null) {
1093                            return cdnHostHttp;
1094                    }
1095    
1096                    try {
1097                            cdnHostHttp = PrefsPropsUtil.getString(
1098                                    companyId, PropsKeys.CDN_HOST_HTTP, PropsValues.CDN_HOST_HTTP);
1099                    }
1100                    catch (Exception e) {
1101                    }
1102    
1103                    if ((cdnHostHttp == null) || cdnHostHttp.startsWith("${")) {
1104                            cdnHostHttp = StringPool.BLANK;
1105                    }
1106    
1107                    _cdnHostHttpMap.put(companyId, cdnHostHttp);
1108    
1109                    return cdnHostHttp;
1110            }
1111    
1112            public String getCDNHostHttps(long companyId) {
1113                    String cdnHostHttps = _cdnHostHttpsMap.get(companyId);
1114    
1115                    if (cdnHostHttps != null) {
1116                            return cdnHostHttps;
1117                    }
1118    
1119                    try {
1120                            cdnHostHttps = PrefsPropsUtil.getString(
1121                                    companyId, PropsKeys.CDN_HOST_HTTPS,
1122                                    PropsValues.CDN_HOST_HTTPS);
1123                    }
1124                    catch (SystemException e) {
1125                    }
1126    
1127                    if ((cdnHostHttps == null) || cdnHostHttps.startsWith("${")) {
1128                            cdnHostHttps = StringPool.BLANK;
1129                    }
1130    
1131                    _cdnHostHttpsMap.put(companyId, cdnHostHttps);
1132    
1133                    return cdnHostHttps;
1134            }
1135    
1136            public String getClassName(long classNameId) {
1137                    try {
1138                            ClassName className = ClassNameLocalServiceUtil.getClassName(
1139                                    classNameId);
1140    
1141                            return className.getValue();
1142                    }
1143                    catch (Exception e) {
1144                            throw new RuntimeException(
1145                                    "Unable to get class name from id " + classNameId);
1146                    }
1147            }
1148    
1149            public long getClassNameId(Class<?> clazz) {
1150                    return ClassNameLocalServiceUtil.getClassNameId(clazz);
1151            }
1152    
1153            public long getClassNameId(String value) {
1154                    return ClassNameLocalServiceUtil.getClassNameId(value);
1155            }
1156    
1157            public String getClassNamePortletId(String className) {
1158                    String portletId = StringPool.BLANK;
1159    
1160                    if (className.startsWith("com.liferay.portlet.blogs")) {
1161                            portletId = PortletKeys.BLOGS;
1162                    }
1163                    else if (className.startsWith("com.liferay.portlet.bookmarks")) {
1164                            portletId = PortletKeys.BOOKMARKS;
1165                    }
1166                    else if (className.startsWith("com.liferay.portlet.calendar")) {
1167                            portletId = PortletKeys.CALENDAR;
1168                    }
1169                    else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
1170                            portletId = PortletKeys.DOCUMENT_LIBRARY;
1171                    }
1172                    else if (className.startsWith("com.liferay.portlet.imagegallery")) {
1173                            portletId = PortletKeys.MEDIA_GALLERY_DISPLAY;
1174                    }
1175                    else if (className.startsWith("com.liferay.portlet.journal")) {
1176                            portletId = PortletKeys.JOURNAL;
1177                    }
1178                    else if (className.startsWith("com.liferay.portlet.messageboards")) {
1179                            portletId = PortletKeys.MESSAGE_BOARDS;
1180                    }
1181                    else if (className.startsWith("com.liferay.portlet.wiki")) {
1182                            portletId = PortletKeys.WIKI;
1183                    }
1184    
1185                    return portletId;
1186            }
1187    
1188            public Company getCompany(HttpServletRequest request)
1189                    throws PortalException, SystemException {
1190    
1191                    long companyId = getCompanyId(request);
1192    
1193                    if (companyId <= 0) {
1194                            return null;
1195                    }
1196    
1197                    Company company = (Company)request.getAttribute(WebKeys.COMPANY);
1198    
1199                    if (company == null) {
1200    
1201                            // LEP-5994
1202    
1203                            try {
1204                                    company = CompanyLocalServiceUtil.getCompanyById(companyId);
1205                            }
1206                            catch (NoSuchCompanyException nsce) {
1207                                    company = CompanyLocalServiceUtil.getCompanyById(
1208                                            PortalInstances.getDefaultCompanyId());
1209                            }
1210    
1211                            request.setAttribute(WebKeys.COMPANY, company);
1212                    }
1213    
1214                    return company;
1215            }
1216    
1217            public Company getCompany(PortletRequest portletRequest)
1218                    throws PortalException, SystemException {
1219    
1220                    return getCompany(getHttpServletRequest(portletRequest));
1221            }
1222    
1223            public long getCompanyId(HttpServletRequest request) {
1224                    return PortalInstances.getCompanyId(request);
1225            }
1226    
1227            public long getCompanyId(PortletRequest portletRequest) {
1228                    return getCompanyId(getHttpServletRequest(portletRequest));
1229            }
1230    
1231            public long[] getCompanyIds() {
1232                    return PortalInstances.getCompanyIds();
1233            }
1234    
1235            public String getComputerAddress() {
1236                    return _computerAddress;
1237            }
1238    
1239            public String getComputerName() {
1240                    return _computerName;
1241            }
1242    
1243            public String getControlPanelCategory(
1244                            String portletId, ThemeDisplay themeDisplay)
1245                    throws SystemException {
1246    
1247                    for (String category : PortletCategoryKeys.ALL) {
1248                            List<Portlet> portlets = getControlPanelPortlets(
1249                                    category, themeDisplay);
1250    
1251                            for (Portlet portlet : portlets) {
1252                                    if (portlet.getPortletId().equals(portletId)) {
1253                                            return category;
1254                                    }
1255                            }
1256                    }
1257    
1258                    return StringPool.BLANK;
1259            }
1260    
1261            public String getControlPanelFullURL(
1262                            long scopeGroupId, String ppid, Map<String, String[]> params)
1263                    throws PortalException, SystemException {
1264    
1265                    StringBundler sb = new StringBundler(6);
1266    
1267                    Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1268    
1269                    Company company = CompanyLocalServiceUtil.getCompany(
1270                            group.getCompanyId());
1271    
1272                    sb.append(
1273                            getPortalURL(
1274                                    company.getVirtualHostname(), getPortalPort(false), false));
1275                    sb.append(getPathFriendlyURLPrivateGroup());
1276                    sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1277                    sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1278    
1279                    if (params != null) {
1280                            params = new HashMap<String, String[]>(params);
1281                    }
1282                    else {
1283                            params = new HashMap<String, String[]>();
1284                    }
1285    
1286                    params.put("p_p_id", new String[] {ppid});
1287                    params.put("p_p_lifecycle", new String[] {"0"});
1288                    params.put(
1289                            "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1290                    params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1291    
1292                    sb.append(HttpUtil.parameterMapToString(params, true));
1293    
1294                    return sb.toString();
1295            }
1296    
1297            public Set<Portlet> getControlPanelPortlets(long companyId, String category)
1298                    throws SystemException {
1299    
1300                    Set<Portlet> portletsSet = new TreeSet<Portlet>(
1301                            new PortletControlPanelWeightComparator());
1302    
1303                    List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1304                            companyId);
1305    
1306                    for (Portlet portlet : portletsList) {
1307                            if (category.equals(portlet.getControlPanelEntryCategory())) {
1308                                    portletsSet.add(portlet);
1309                            }
1310                    }
1311    
1312                    return portletsSet;
1313            }
1314    
1315            public List<Portlet> getControlPanelPortlets(
1316                            String category, ThemeDisplay themeDisplay)
1317                    throws SystemException {
1318    
1319                    Set<Portlet> portlets = getControlPanelPortlets(
1320                            themeDisplay.getCompanyId(), category);
1321    
1322                    return filterControlPanelPortlets(portlets, category, themeDisplay);
1323            }
1324    
1325            public String getCreateAccountURL(
1326                            HttpServletRequest request, ThemeDisplay themeDisplay)
1327                    throws Exception {
1328    
1329                    if (Validator.isNull(PropsValues.COMPANY_SECURITY_STRANGERS_URL)) {
1330                            PortletURL createAccountURL = PortletURLFactoryUtil.create(
1331                                    request, PortletKeys.LOGIN, themeDisplay.getPlid(),
1332                                    PortletRequest.RENDER_PHASE);
1333    
1334                            createAccountURL.setWindowState(WindowState.MAXIMIZED);
1335                            createAccountURL.setPortletMode(PortletMode.VIEW);
1336    
1337                            createAccountURL.setParameter("saveLastPath", "0");
1338                            createAccountURL.setParameter(
1339                                    "struts_action", "/login/create_account");
1340    
1341                            return createAccountURL.toString();
1342                    }
1343    
1344                    try {
1345                            Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1346                                    themeDisplay.getScopeGroupId(), false,
1347                                    PropsValues.COMPANY_SECURITY_STRANGERS_URL);
1348    
1349                            return PortalUtil.getLayoutURL(layout, themeDisplay);
1350                    }
1351                    catch (NoSuchLayoutException nsle) {
1352                    }
1353    
1354                    return StringPool.BLANK;
1355            }
1356    
1357            public String getCurrentCompleteURL(HttpServletRequest request) {
1358                    String currentCompleteURL = (String)request.getAttribute(
1359                            WebKeys.CURRENT_COMPLETE_URL);
1360    
1361                    if (currentCompleteURL == null) {
1362                            currentCompleteURL = HttpUtil.getCompleteURL(request);
1363    
1364                            request.setAttribute(
1365                                    WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1366                    }
1367    
1368                    return currentCompleteURL;
1369            }
1370    
1371            public String getCurrentURL(HttpServletRequest request) {
1372                    String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1373    
1374                    if (currentURL != null) {
1375                            return currentURL;
1376                    }
1377    
1378                    currentURL = ParamUtil.getString(request, "currentURL");
1379    
1380                    if (Validator.isNull(currentURL)) {
1381                            currentURL = HttpUtil.getCompleteURL(request);
1382    
1383                            if ((Validator.isNotNull(currentURL)) &&
1384                                    (currentURL.indexOf(_J_SECURITY_CHECK) == -1)) {
1385    
1386                                    currentURL = currentURL.substring(
1387                                            currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1388                                                    Http.PROTOCOL_DELIMITER.length());
1389    
1390                                    currentURL = currentURL.substring(
1391                                            currentURL.indexOf(CharPool.SLASH));
1392                            }
1393    
1394                            if (Validator.isNotNull(currentURL) &&
1395                                    FacebookUtil.isFacebook(currentURL)) {
1396    
1397                                    String[] facebookData = FacebookUtil.getFacebookData(request);
1398    
1399                                    currentURL =
1400                                            FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1401                                                    facebookData[2];
1402                            }
1403                    }
1404    
1405                    if (Validator.isNull(currentURL)) {
1406                            currentURL = getPathMain();
1407                    }
1408    
1409                    request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1410    
1411                    return currentURL;
1412            }
1413    
1414            public String getCurrentURL(PortletRequest portletRequest) {
1415                    return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1416            }
1417    
1418            public String getCustomSQLFunctionIsNotNull() {
1419                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1420            }
1421    
1422            public String getCustomSQLFunctionIsNull() {
1423                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1424            }
1425    
1426            public Date getDate(int month, int day, int year) {
1427                    try {
1428                            return getDate(month, day, year, null);
1429                    }
1430                    catch (PortalException pe) {
1431                            throw new RuntimeException();
1432                    }
1433            }
1434    
1435            public Date getDate(
1436                            int month, int day, int year, int hour, int min, PortalException pe)
1437                    throws PortalException {
1438    
1439                    return getDate(month, day, year, hour, min, null, pe);
1440            }
1441    
1442            public Date getDate(
1443                            int month, int day, int year, int hour, int min, TimeZone timeZone,
1444                            PortalException pe)
1445                    throws PortalException {
1446    
1447                    if (!Validator.isGregorianDate(month, day, year)) {
1448                            if (pe != null) {
1449                                    throw pe;
1450                            }
1451                            else {
1452                                    return null;
1453                            }
1454                    }
1455                    else {
1456                            Calendar cal = null;
1457    
1458                            if (timeZone == null) {
1459                                    cal = CalendarFactoryUtil.getCalendar();
1460                            }
1461                            else {
1462                                    cal = CalendarFactoryUtil.getCalendar(timeZone);
1463                            }
1464    
1465                            if ((hour == -1) || (min == -1)) {
1466                                    cal.set(year, month, day, 0, 0, 0);
1467                            }
1468                            else {
1469                                    cal.set(year, month, day, hour, min, 0);
1470                            }
1471    
1472                            cal.set(Calendar.MILLISECOND, 0);
1473    
1474                            Date date = cal.getTime();
1475    
1476                            /*if (timeZone != null &&
1477                                    cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
1478    
1479                                    throw pe;
1480                            }*/
1481    
1482                            return date;
1483                    }
1484            }
1485    
1486            public Date getDate(int month, int day, int year, PortalException pe)
1487                    throws PortalException {
1488    
1489                    return getDate(month, day, year, null, pe);
1490            }
1491    
1492            public Date getDate(
1493                            int month, int day, int year, TimeZone timeZone, PortalException pe)
1494                    throws PortalException {
1495    
1496                    return getDate(month, day, year, -1, -1, timeZone, pe);
1497            }
1498    
1499            public long getDefaultCompanyId() {
1500                    return PortalInstances.getDefaultCompanyId();
1501            }
1502    
1503            public long getDigestAuthUserId(HttpServletRequest request)
1504                    throws PortalException, SystemException {
1505    
1506                    long userId = 0;
1507    
1508                    String authorizationHeader = request.getHeader(
1509                            HttpHeaders.AUTHORIZATION);
1510    
1511                    if (Validator.isNull(authorizationHeader) ||
1512                            !authorizationHeader.startsWith("Digest ")) {
1513    
1514                            return userId;
1515                    }
1516    
1517                    authorizationHeader = authorizationHeader.substring("Digest ".length());
1518                    authorizationHeader = StringUtil.replace(
1519                            authorizationHeader, CharPool.COMMA, CharPool.NEW_LINE);
1520    
1521                    UnicodeProperties authorizationProperties = new UnicodeProperties();
1522    
1523                    authorizationProperties.fastLoad(authorizationHeader);
1524    
1525                    String username = StringUtil.unquote(
1526                            authorizationProperties.getProperty("username"));
1527                    String realm = StringUtil.unquote(
1528                            authorizationProperties.getProperty("realm"));
1529                    String nonce = StringUtil.unquote(
1530                            authorizationProperties.getProperty("nonce"));
1531                    String uri = StringUtil.unquote(
1532                            authorizationProperties.getProperty("uri"));
1533                    String response = StringUtil.unquote(
1534                            authorizationProperties.getProperty("response"));
1535    
1536                    if (Validator.isNull(username) || Validator.isNull(realm) ||
1537                            Validator.isNull(nonce) || Validator.isNull(uri) ||
1538                            Validator.isNull(response)) {
1539    
1540                            return userId;
1541                    }
1542    
1543                    if (!realm.equals(PORTAL_REALM) ||
1544                            !uri.equals(request.getRequestURI())) {
1545    
1546                            return userId;
1547                    }
1548    
1549                    if (!NonceUtil.verify(nonce)) {
1550                            return userId;
1551                    }
1552    
1553                    long companyId = PortalInstances.getCompanyId(request);
1554    
1555                    userId = UserLocalServiceUtil.authenticateForDigest(
1556                            companyId, username, realm, nonce, request.getMethod(), uri,
1557                            response);
1558    
1559                    return userId;
1560            }
1561    
1562            public String getEmailFromAddress(
1563                            PortletPreferences preferences, long companyId, String defaultValue)
1564                    throws SystemException {
1565    
1566                    if (Validator.isNull(defaultValue)) {
1567                            defaultValue = PrefsPropsUtil.getString(
1568                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_ADDRESS);
1569                    }
1570    
1571                    return preferences.getValue("emailFromAddress", defaultValue);
1572            }
1573    
1574            public String getEmailFromName(
1575                            PortletPreferences preferences, long companyId, String defaultValue)
1576                    throws SystemException {
1577    
1578                    if (Validator.isNull(defaultValue)) {
1579                            defaultValue = PrefsPropsUtil.getString(
1580                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_NAME);
1581                    }
1582    
1583                    return preferences.getValue("emailFromName", defaultValue);
1584            }
1585    
1586            public Map<String, Serializable> getExpandoBridgeAttributes(
1587                            ExpandoBridge expandoBridge, PortletRequest portletRequest)
1588                    throws PortalException, SystemException {
1589    
1590                    Map<String, Serializable> attributes =
1591                            new HashMap<String, Serializable>();
1592    
1593                    List<String> names = new ArrayList<String>();
1594    
1595                    Enumeration<String> enu = portletRequest.getParameterNames();
1596    
1597                    while (enu.hasMoreElements()) {
1598                            String param = enu.nextElement();
1599    
1600                            if (param.indexOf("ExpandoAttributeName--") != -1) {
1601                                    String name = ParamUtil.getString(portletRequest, param);
1602    
1603                                    names.add(name);
1604                            }
1605                    }
1606    
1607                    for (String name : names) {
1608                            int type = expandoBridge.getAttributeType(name);
1609    
1610                            UnicodeProperties properties = expandoBridge.getAttributeProperties(
1611                                    name);
1612    
1613                            String displayType = GetterUtil.getString(
1614                                    properties.getProperty(
1615                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
1616                                    ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
1617    
1618                            Serializable value = getExpandoValue(
1619                                    portletRequest, "ExpandoAttribute--" + name + "--", type,
1620                                    displayType);
1621    
1622                            attributes.put(name, value);
1623                    }
1624    
1625                    return attributes;
1626            }
1627    
1628            public Serializable getExpandoValue(
1629                            PortletRequest portletRequest, String name, int type,
1630                            String displayType)
1631                    throws PortalException, SystemException {
1632    
1633                    Serializable value = null;
1634    
1635                    if (type == ExpandoColumnConstants.BOOLEAN) {
1636                            value = ParamUtil.getBoolean(portletRequest, name);
1637                    }
1638                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1639                    }
1640                    else if (type == ExpandoColumnConstants.DATE) {
1641                            int valueDateMonth = ParamUtil.getInteger(
1642                                    portletRequest, name + "Month");
1643                            int valueDateDay = ParamUtil.getInteger(
1644                                    portletRequest, name + "Day");
1645                            int valueDateYear = ParamUtil.getInteger(
1646                                    portletRequest, name + "Year");
1647                            int valueDateHour = ParamUtil.getInteger(
1648                                    portletRequest, name + "Hour");
1649                            int valueDateMinute = ParamUtil.getInteger(
1650                                    portletRequest, name + "Minute");
1651                            int valueDateAmPm = ParamUtil.getInteger(
1652                                    portletRequest, name + "AmPm");
1653    
1654                            if (valueDateAmPm == Calendar.PM) {
1655                                    valueDateHour += 12;
1656                            }
1657    
1658                            TimeZone timeZone = null;
1659    
1660                            User user = getUser(portletRequest);
1661    
1662                            if (user != null) {
1663                                    timeZone = user.getTimeZone();
1664                            }
1665    
1666                            value = getDate(
1667                                    valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
1668                                    valueDateMinute, timeZone, new ValueDataException());
1669                    }
1670                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1671                    }
1672                    else if (type == ExpandoColumnConstants.DOUBLE) {
1673                            value = ParamUtil.getDouble(portletRequest, name);
1674                    }
1675                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1676                            String[] values = portletRequest.getParameterValues(name);
1677    
1678                            if (displayType.equals(
1679                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1680    
1681                                    values = StringUtil.splitLines(values[0]);
1682                            }
1683    
1684                            value = GetterUtil.getDoubleValues(values);
1685                    }
1686                    else if (type == ExpandoColumnConstants.FLOAT) {
1687                            value = ParamUtil.getFloat(portletRequest, name);
1688                    }
1689                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1690                            String[] values = portletRequest.getParameterValues(name);
1691    
1692                            if (displayType.equals(
1693                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1694    
1695                                    values = StringUtil.splitLines(values[0]);
1696                            }
1697    
1698                            value = GetterUtil.getFloatValues(values);
1699                    }
1700                    else if (type == ExpandoColumnConstants.INTEGER) {
1701                            value = ParamUtil.getInteger(portletRequest, name);
1702                    }
1703                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
1704                            String[] values = portletRequest.getParameterValues(name);
1705    
1706                            if (displayType.equals(
1707                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1708    
1709                                    values = StringUtil.splitLines(values[0]);
1710                            }
1711    
1712                            value = GetterUtil.getIntegerValues(values);
1713                    }
1714                    else if (type == ExpandoColumnConstants.LONG) {
1715                            value = ParamUtil.getLong(portletRequest, name);
1716                    }
1717                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
1718                            String[] values = portletRequest.getParameterValues(name);
1719    
1720                            if (displayType.equals(
1721                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1722    
1723                                    values = StringUtil.splitLines(values[0]);
1724                            }
1725    
1726                            value = GetterUtil.getLongValues(values);
1727                    }
1728                    else if (type == ExpandoColumnConstants.SHORT) {
1729                            value = ParamUtil.getShort(portletRequest, name);
1730                    }
1731                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
1732                            String[] values = portletRequest.getParameterValues(name);
1733    
1734                            if (displayType.equals(
1735                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1736    
1737                                    values = StringUtil.splitLines(values[0]);
1738                            }
1739    
1740                            value = GetterUtil.getShortValues(values);
1741                    }
1742                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
1743                            value = portletRequest.getParameterValues(name);
1744                    }
1745                    else {
1746                            value = ParamUtil.getString(portletRequest, name);
1747                    }
1748    
1749                    return value;
1750            }
1751    
1752            public String getFacebookURL(
1753                            Portlet portlet, String facebookCanvasPageURL,
1754                            ThemeDisplay themeDisplay)
1755                    throws PortalException, SystemException {
1756    
1757                    String facebookURL = getServletURL(
1758                            portlet, FacebookUtil.FACEBOOK_SERVLET_PATH + facebookCanvasPageURL,
1759                            themeDisplay);
1760    
1761                    if (!facebookURL.endsWith(StringPool.SLASH)) {
1762                            facebookURL += StringPool.SLASH;
1763                    }
1764    
1765                    return facebookURL;
1766            }
1767    
1768            public String getFirstPageLayoutTypes(PageContext pageContext) {
1769                    StringBundler sb = new StringBundler();
1770    
1771                    for (String type : PropsValues.LAYOUT_TYPES) {
1772                            if (isLayoutFirstPageable(type)) {
1773                                    sb.append(
1774                                            LanguageUtil.get(pageContext, "layout.types." + type));
1775                                    sb.append(StringPool.COMMA);
1776                                    sb.append(StringPool.SPACE);
1777                            }
1778                    }
1779    
1780                    if (sb.index() >= 2) {
1781                            sb.setIndex(sb.index() - 2);
1782                    }
1783    
1784                    return sb.toString();
1785            }
1786    
1787            public String getGlobalLibDir() {
1788                    return PropsValues.LIFERAY_LIB_GLOBAL_DIR;
1789            }
1790    
1791            public String getGoogleGadgetURL(Portlet portlet, ThemeDisplay themeDisplay)
1792                    throws PortalException, SystemException {
1793    
1794                    return getServletURL(
1795                            portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
1796            }
1797    
1798            public String getGroupFriendlyURL(
1799                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay)
1800                    throws PortalException, SystemException {
1801    
1802                    return getGroupFriendlyURL(
1803                            group, privateLayoutSet, themeDisplay, false);
1804            }
1805    
1806            public String[] getGroupPermissions(HttpServletRequest request) {
1807                    return request.getParameterValues("groupPermissions");
1808            }
1809    
1810            public String[] getGroupPermissions(PortletRequest portletRequest) {
1811                    return portletRequest.getParameterValues("groupPermissions");
1812            }
1813    
1814            public String[] getGuestPermissions(HttpServletRequest request) {
1815                    return request.getParameterValues("guestPermissions");
1816            }
1817    
1818            public String[] getGuestPermissions(PortletRequest portletRequest) {
1819                    return portletRequest.getParameterValues("guestPermissions");
1820            }
1821    
1822            public String getHomeURL(HttpServletRequest request)
1823                    throws PortalException, SystemException {
1824    
1825                    String portalURL = getPortalURL(request);
1826    
1827                    return portalURL + _pathContext + getRelativeHomeURL(request);
1828            }
1829    
1830            public String getHost(HttpServletRequest request) {
1831                    request = getOriginalServletRequest(request);
1832    
1833                    String host = request.getHeader("Host");
1834    
1835                    if (host != null) {
1836                            host = host.trim().toLowerCase();
1837    
1838                            int pos = host.indexOf(':');
1839    
1840                            if (pos >= 0) {
1841                                    host = host.substring(0, pos);
1842                            }
1843                    }
1844                    else {
1845                            host = null;
1846                    }
1847    
1848                    return host;
1849            }
1850    
1851            public String getHost(PortletRequest portletRequest) {
1852                    return getHost(getHttpServletRequest(portletRequest));
1853            }
1854    
1855            public HttpServletRequest getHttpServletRequest(
1856                    PortletRequest portletRequest) {
1857    
1858                    PortletRequestImpl portletRequestImpl =
1859                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
1860    
1861                    return portletRequestImpl.getHttpServletRequest();
1862            }
1863    
1864            public HttpServletResponse getHttpServletResponse(
1865                    PortletResponse portletResponse) {
1866    
1867                    PortletResponseImpl portletResponseImpl =
1868                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
1869    
1870                    return portletResponseImpl.getHttpServletResponse();
1871            }
1872    
1873            public String getJournalArticleActualURL(
1874                            long groupId, String mainPath, String friendlyURL,
1875                            Map<String, String[]> params, Map<String, Object> requestContext)
1876                    throws PortalException, SystemException {
1877    
1878                    String articleUrlTitle = friendlyURL.substring(
1879                            JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
1880    
1881                    JournalArticle journalArticle =
1882                            JournalArticleLocalServiceUtil.getArticleByUrlTitle(
1883                                    groupId, articleUrlTitle);
1884    
1885                    Layout layout = LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
1886                            journalArticle.getLayoutUuid(), groupId);
1887    
1888                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
1889    
1890                    InheritableMap<String, String[]> actualParams =
1891                            new InheritableMap<String, String[]>();
1892    
1893                    if (params != null) {
1894                            actualParams.setParentMap(params);
1895                    }
1896    
1897                    UnicodeProperties typeSettingsProperties =
1898                            layout.getTypeSettingsProperties();
1899    
1900                    String defaultAssetPublisherPortletId = typeSettingsProperties.get(
1901                            LayoutTypePortletConstants.DEFAULT_ASSET_PUBLISHER_PORTLET_ID);
1902    
1903                    String currentDefaultAssetPublisherPortletId =
1904                            defaultAssetPublisherPortletId;
1905    
1906                    if (Validator.isNull(defaultAssetPublisherPortletId)) {
1907                            defaultAssetPublisherPortletId =
1908                                    PortletKeys.ASSET_PUBLISHER +
1909                                            LayoutTypePortletImpl.getFullInstanceSeparator();
1910                    }
1911    
1912                    HttpServletRequest request =
1913                            (HttpServletRequest)requestContext.get("request");
1914    
1915                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
1916                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
1917                                    request, layout.getPlid(), defaultAssetPublisherPortletId);
1918    
1919                            actualParams.put(
1920                                    "p_p_auth", new String[] {actualPortletAuthenticationToken});
1921                    }
1922    
1923                    actualParams.put(
1924                            "p_p_id", new String[] {defaultAssetPublisherPortletId});
1925                    actualParams.put("p_p_lifecycle", new String[] {"0"});
1926    
1927                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
1928                            actualParams.put(
1929                                    "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1930                    }
1931    
1932                    actualParams.put("p_p_mode", new String[] {"view"});
1933                    actualParams.put(
1934                            "p_j_a_id", new String[] {String.valueOf(journalArticle.getId())});
1935    
1936                    String namespace = getPortletNamespace(defaultAssetPublisherPortletId);
1937    
1938                    actualParams.put(
1939                            namespace + "struts_action",
1940                            new String[] {"/asset_publisher/view_content"});
1941                    actualParams.put(
1942                            namespace + "type",
1943                            new String[] {JournalArticleAssetRendererFactory.TYPE});
1944                    actualParams.put(
1945                            namespace + "urlTitle",
1946                            new String[] {journalArticle.getUrlTitle()});
1947    
1948                    String queryString = HttpUtil.parameterMapToString(actualParams, false);
1949    
1950                    if (layoutActualURL.contains(StringPool.QUESTION)) {
1951                            layoutActualURL =
1952                                    layoutActualURL + StringPool.AMPERSAND + queryString;
1953                    }
1954                    else {
1955                            layoutActualURL =
1956                                    layoutActualURL + StringPool.QUESTION + queryString;
1957                    }
1958    
1959                    Locale locale = getLocale(request);
1960    
1961                    addPageSubtitle(journalArticle.getTitle(locale), request);
1962                    addPageDescription(journalArticle.getDescription(locale), request);
1963    
1964                    List<AssetTag> assetTags =
1965                            AssetTagLocalServiceUtil.getTags(
1966                                    JournalArticle.class.getName(), journalArticle.getPrimaryKey());
1967    
1968                    if (!assetTags.isEmpty()) {
1969                            addPageKeywords(
1970                                    ListUtil.toString(assetTags, AssetTag.NAME_ACCESSOR),
1971                                    request);
1972                    }
1973    
1974                    return layoutActualURL;
1975            }
1976    
1977            public String getJsSafePortletId(String portletId) {
1978                    return JS.getSafeName(portletId);
1979            }
1980    
1981            public String getLayoutActualURL(Layout layout) {
1982                    return getLayoutActualURL(layout, getPathMain());
1983            }
1984    
1985            public String getLayoutActualURL(Layout layout, String mainPath) {
1986                    Map<String, String> variables = new HashMap<String, String>();
1987    
1988                    variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
1989                    variables.put("liferay:mainPath", mainPath);
1990                    variables.put("liferay:plid", String.valueOf(layout.getPlid()));
1991    
1992                    if (layout instanceof VirtualLayout) {
1993                            variables.put(
1994                                    "liferay:pvlsgid", String.valueOf(layout.getGroupId()));
1995                    }
1996                    else {
1997                            variables.put("liferay:pvlsgid", "0");
1998                    }
1999    
2000                    LayoutType layoutType = layout.getLayoutType();
2001    
2002                    UnicodeProperties typeSettingsProperties =
2003                            layoutType.getTypeSettingsProperties();
2004    
2005                    variables.putAll(typeSettingsProperties);
2006    
2007                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
2008    
2009                    return layoutSettings.getURL(variables);
2010            }
2011    
2012            public String getLayoutActualURL(
2013                            long groupId, boolean privateLayout, String mainPath,
2014                            String friendlyURL)
2015                    throws PortalException, SystemException {
2016    
2017                    return getLayoutActualURL(
2018                            groupId, privateLayout, mainPath, friendlyURL, null, null);
2019            }
2020    
2021            public String getLayoutActualURL(
2022                            long groupId, boolean privateLayout, String mainPath,
2023                            String friendlyURL, Map<String, String[]> params,
2024                            Map<String, Object> requestContext)
2025                    throws PortalException, SystemException {
2026    
2027                    Layout layout = null;
2028                    String queryString = StringPool.BLANK;
2029    
2030                    if (Validator.isNull(friendlyURL)) {
2031                            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2032                                    groupId, privateLayout,
2033                                    LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
2034    
2035                            if (!layouts.isEmpty()) {
2036                                    layout = layouts.get(0);
2037                            }
2038                            else {
2039                                    throw new NoSuchLayoutException(
2040                                            "{groupId=" + groupId + ",privateLayout=" + privateLayout +
2041                                                    "} does not have any layouts");
2042                            }
2043                    }
2044                    else {
2045                            Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
2046                                    groupId, privateLayout, friendlyURL, params, requestContext);
2047    
2048                            layout = (Layout)friendlyURLMapper[0];
2049                            queryString = (String)friendlyURLMapper[1];
2050                    }
2051    
2052                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
2053    
2054                    if (Validator.isNotNull(queryString)) {
2055                            layoutActualURL = layoutActualURL.concat(queryString);
2056                    }
2057                    else if (params.isEmpty()) {
2058                            LayoutType layoutType = layout.getLayoutType();
2059    
2060                            UnicodeProperties typeSettingsProperties =
2061                                    layoutType.getTypeSettingsProperties();
2062    
2063                            queryString = typeSettingsProperties.getProperty("query-string");
2064    
2065                            if (Validator.isNotNull(queryString) &&
2066                                    layoutActualURL.contains(StringPool.QUESTION)) {
2067    
2068                                    layoutActualURL =
2069                                            layoutActualURL.concat(StringPool.AMPERSAND).concat(
2070                                                    queryString);
2071                            }
2072                    }
2073    
2074                    return layoutActualURL;
2075            }
2076    
2077            public String getLayoutEditPage(Layout layout) {
2078                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
2079                            layout.getType());
2080    
2081                    return layoutSettings.getEditPage();
2082            }
2083    
2084            public String getLayoutEditPage(String type) {
2085                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2086    
2087                    return layoutSettings.getEditPage();
2088            }
2089    
2090            public String getLayoutFriendlyURL(Layout layout, ThemeDisplay themeDisplay)
2091                    throws PortalException, SystemException {
2092    
2093                    if (!isLayoutFriendliable(layout)) {
2094                            return null;
2095                    }
2096    
2097                    String groupFriendlyURL = getGroupFriendlyURL(
2098                            layout.getGroup(), layout.isPrivateLayout(), themeDisplay);
2099    
2100                    return groupFriendlyURL.concat(layout.getFriendlyURL());
2101            }
2102    
2103            public String getLayoutFriendlyURL(
2104                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
2105                    throws PortalException, SystemException {
2106    
2107                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
2108                    String i18nPath = themeDisplay.getI18nPath();
2109    
2110                    try {
2111                            String tempI18nLanguageId = null;
2112                            String tempI18nPath = null;
2113    
2114                            if (((I18nFilter.getLanguageIds().contains(locale.toString())) &&
2115                                    ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
2116                                     (!locale.equals(LocaleUtil.getDefault())))) ||
2117                                    (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
2118    
2119                                    tempI18nLanguageId = locale.toString();
2120                                    tempI18nPath = buildI18NPath(locale);
2121                            }
2122    
2123                            themeDisplay.setI18nLanguageId(tempI18nLanguageId);
2124                            themeDisplay.setI18nPath(tempI18nPath);
2125    
2126                            return getLayoutFriendlyURL(layout, themeDisplay);
2127                    }
2128                    finally {
2129                            themeDisplay.setI18nLanguageId(i18nLanguageId);
2130                            themeDisplay.setI18nPath(i18nPath);
2131                    }
2132            }
2133    
2134            public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
2135                    throws PortalException, SystemException {
2136    
2137                    return getLayoutFullURL(layout, themeDisplay, true);
2138            }
2139    
2140            public String getLayoutFullURL(
2141                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2142                    throws PortalException, SystemException {
2143    
2144                    String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
2145                    String portalURL = getPortalURL(layout, themeDisplay);
2146    
2147                    if (StringUtil.startsWith(layoutURL, portalURL)) {
2148                            return layoutURL;
2149                    }
2150                    else {
2151                            return portalURL + layoutURL;
2152                    }
2153            }
2154    
2155            public String getLayoutFullURL(long groupId, String portletId)
2156                    throws PortalException, SystemException {
2157    
2158                    return getLayoutFullURL(groupId, portletId, false);
2159            }
2160    
2161            public String getLayoutFullURL(
2162                            long groupId, String portletId, boolean secure)
2163                    throws PortalException, SystemException {
2164    
2165                    long plid = getPlidFromPortletId(groupId, portletId);
2166    
2167                    if (plid == LayoutConstants.DEFAULT_PLID) {
2168                            return null;
2169                    }
2170    
2171                    StringBundler sb = new StringBundler(4);
2172    
2173                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2174    
2175                    Group group = GroupLocalServiceUtil.getGroup(groupId);
2176    
2177                    if (group.isLayout()) {
2178                            long parentGroupId = group.getParentGroupId();
2179    
2180                            if (parentGroupId > 0) {
2181                                    group = GroupLocalServiceUtil.getGroup(parentGroupId);
2182                            }
2183                    }
2184    
2185                    String virtualHostname = null;
2186    
2187                    LayoutSet layoutSet = layout.getLayoutSet();
2188    
2189                    if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
2190                            virtualHostname = layoutSet.getVirtualHostname();
2191                    }
2192                    else {
2193                            Company company = CompanyLocalServiceUtil.getCompany(
2194                                    layout.getCompanyId());
2195    
2196                            virtualHostname = company.getVirtualHostname();
2197                    }
2198    
2199                    String portalURL = getPortalURL(
2200                            virtualHostname, getPortalPort(secure), secure);
2201    
2202                    sb.append(portalURL);
2203    
2204                    if (layout.isPrivateLayout()) {
2205                            if (group.isUser()) {
2206                                    sb.append(getPathFriendlyURLPrivateUser());
2207                            }
2208                            else {
2209                                    sb.append(getPathFriendlyURLPrivateGroup());
2210                            }
2211                    }
2212                    else {
2213                            sb.append(getPathFriendlyURLPublic());
2214                    }
2215    
2216                    sb.append(group.getFriendlyURL());
2217                    sb.append(layout.getFriendlyURL());
2218    
2219                    return sb.toString();
2220            }
2221    
2222            public String getLayoutFullURL(ThemeDisplay themeDisplay)
2223                    throws PortalException, SystemException {
2224    
2225                    return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
2226            }
2227    
2228            public String getLayoutSetFriendlyURL(
2229                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
2230                    throws PortalException, SystemException {
2231    
2232                    String virtualHostname = layoutSet.getVirtualHostname();
2233    
2234                    if (Validator.isNull(virtualHostname) &&
2235                            Validator.isNotNull(PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
2236                            !layoutSet.isPrivateLayout()) {
2237    
2238                            try {
2239                                    Group group = GroupLocalServiceUtil.getGroup(
2240                                            themeDisplay.getCompanyId(),
2241                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
2242    
2243                                    if (layoutSet.getGroupId() == group.getGroupId()) {
2244                                            Company company = themeDisplay.getCompany();
2245    
2246                                            virtualHostname = company.getVirtualHostname();
2247                                    }
2248                            }
2249                            catch (Exception e) {
2250                                    _log.error(e, e);
2251                            }
2252                    }
2253    
2254                    if (Validator.isNotNull(virtualHostname)) {
2255                            String portalURL = getPortalURL(
2256                                    virtualHostname, themeDisplay.getServerPort(),
2257                                    themeDisplay.isSecure());
2258    
2259                            // Use the layout set's virtual host setting only if the layout set
2260                            // is already used for the current request
2261    
2262                            long curLayoutSetId =
2263                                    themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
2264    
2265                            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
2266                                    (portalURL.startsWith(themeDisplay.getURLPortal()))) {
2267    
2268                                    String layoutSetFriendlyURL = StringPool.BLANK;
2269    
2270                                    if (themeDisplay.isI18n()) {
2271                                            layoutSetFriendlyURL = themeDisplay.getI18nPath();
2272                                    }
2273    
2274                                    return portalURL + _pathContext + layoutSetFriendlyURL;
2275                            }
2276                    }
2277    
2278                    Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
2279    
2280                    String friendlyURL = null;
2281    
2282                    if (layoutSet.isPrivateLayout()) {
2283                            if (group.isUser()) {
2284                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
2285                            }
2286                            else {
2287                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
2288                            }
2289                    }
2290                    else {
2291                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
2292                    }
2293    
2294                    if (themeDisplay.isI18n()) {
2295                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
2296                    }
2297    
2298                    return _pathContext + friendlyURL + group.getFriendlyURL();
2299            }
2300    
2301            public String getLayoutTarget(Layout layout) {
2302                    UnicodeProperties typeSettingsProps =
2303                            layout.getTypeSettingsProperties();
2304    
2305                    String target = typeSettingsProps.getProperty("target");
2306    
2307                    if (Validator.isNull(target)) {
2308                            target = StringPool.BLANK;
2309                    }
2310                    else {
2311                            target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
2312                    }
2313    
2314                    return target;
2315            }
2316    
2317            public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
2318                    throws PortalException, SystemException {
2319    
2320                    return getLayoutURL(layout, themeDisplay, true);
2321            }
2322    
2323            public String getLayoutURL(
2324                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2325                    throws PortalException, SystemException {
2326    
2327                    if (layout == null) {
2328                            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
2329                    }
2330    
2331                    if (!layout.isTypeURL()) {
2332                            String layoutFriendlyURL = getLayoutFriendlyURL(
2333                                    layout, themeDisplay);
2334    
2335                            if (Validator.isNotNull(layoutFriendlyURL)) {
2336                                    layoutFriendlyURL = addPreservedParameters(
2337                                            themeDisplay, layout, layoutFriendlyURL, doAsUser);
2338    
2339                                    return layoutFriendlyURL;
2340                            }
2341                    }
2342    
2343                    String layoutURL = getLayoutActualURL(layout);
2344    
2345                    layoutURL = addPreservedParameters(
2346                            themeDisplay, layout, layoutURL, doAsUser);
2347    
2348                    return layoutURL;
2349            }
2350    
2351            public String getLayoutURL(ThemeDisplay themeDisplay)
2352                    throws PortalException, SystemException {
2353    
2354                    return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
2355            }
2356    
2357            public String getLayoutViewPage(Layout layout) {
2358                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
2359                            layout.getType());
2360    
2361                    return layoutSettings.getViewPage();
2362            }
2363    
2364            public String getLayoutViewPage(String type) {
2365                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2366    
2367                    return layoutSettings.getViewPage();
2368            }
2369    
2370            public LiferayPortletRequest getLiferayPortletRequest(
2371                    PortletRequest portletRequest) {
2372    
2373                    PortletRequestImpl portletRequestImpl =
2374                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
2375    
2376                    return portletRequestImpl;
2377            }
2378    
2379            public LiferayPortletResponse getLiferayPortletResponse(
2380                    PortletResponse portletResponse) {
2381    
2382                    PortletResponseImpl portletResponseImpl =
2383                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
2384    
2385                    return portletResponseImpl;
2386            }
2387    
2388            public Locale getLocale(HttpServletRequest request) {
2389                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2390                            WebKeys.THEME_DISPLAY);
2391    
2392                    if (themeDisplay != null) {
2393                            return themeDisplay.getLocale();
2394                    }
2395                    else {
2396                            HttpSession session = request.getSession();
2397    
2398                            return (Locale)session.getAttribute(Globals.LOCALE_KEY);
2399                    }
2400            }
2401    
2402            public Locale getLocale(RenderRequest renderRequest) {
2403                    return getLocale(getHttpServletRequest(renderRequest));
2404            }
2405    
2406            public String getMailId(String mx, String popPortletPrefix, Object... ids) {
2407                    StringBundler sb = new StringBundler(ids.length * 2 + 7);
2408    
2409                    sb.append(StringPool.LESS_THAN);
2410                    sb.append(popPortletPrefix);
2411    
2412                    if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
2413                            sb.append(StringPool.PERIOD);
2414                    }
2415    
2416                    for (int i = 0; i < ids.length; i++) {
2417                            Object id = ids[i];
2418    
2419                            if (i != 0) {
2420                                    sb.append(StringPool.PERIOD);
2421                            }
2422    
2423                            sb.append(id);
2424                    }
2425    
2426                    sb.append(StringPool.AT);
2427    
2428                    if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
2429                            sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
2430                            sb.append(StringPool.PERIOD);
2431                    }
2432    
2433                    sb.append(mx);
2434                    sb.append(StringPool.GREATER_THAN);
2435    
2436                    return sb.toString();
2437            }
2438    
2439            public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
2440                    throws PortalException, SystemException {
2441    
2442                    return getServletURL(
2443                            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
2444            }
2445    
2446            public String getNewPortletTitle(
2447                    String portletTitle, String oldScopeName, String newScopeName) {
2448    
2449                    if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
2450                            int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
2451    
2452                            portletTitle = portletTitle.substring(0, pos);
2453                    }
2454    
2455                    if (Validator.isNull(newScopeName)) {
2456                            return portletTitle;
2457                    }
2458    
2459                    StringBundler sb = new StringBundler(5);
2460    
2461                    sb.append(portletTitle);
2462                    sb.append(StringPool.SPACE);
2463                    sb.append(StringPool.OPEN_PARENTHESIS);
2464                    sb.append(newScopeName);
2465                    sb.append(StringPool.CLOSE_PARENTHESIS);
2466    
2467                    return sb.toString();
2468            }
2469    
2470            public HttpServletRequest getOriginalServletRequest(
2471                    HttpServletRequest request) {
2472    
2473                    HttpServletRequest originalRequest = request;
2474    
2475                    while (originalRequest.getClass().getName().startsWith(
2476                                            "com.liferay.")) {
2477    
2478                            // Get original request so that portlets inside portlets render
2479                            // properly
2480    
2481                            originalRequest = (HttpServletRequest)
2482                                    ((HttpServletRequestWrapper)originalRequest).getRequest();
2483                    }
2484    
2485                    return originalRequest;
2486            }
2487    
2488            public String getOuterPortletId(HttpServletRequest request) {
2489                    String outerPortletId = (String)request.getAttribute(
2490                            WebKeys.OUTER_PORTLET_ID);
2491    
2492                    if (outerPortletId == null) {
2493                            outerPortletId = request.getParameter("p_o_p_id");
2494                    }
2495    
2496                    return outerPortletId;
2497            }
2498    
2499            public long getParentGroupId(long groupId)
2500                    throws PortalException, SystemException {
2501    
2502                    if (groupId <= 0) {
2503                            return 0;
2504                    }
2505    
2506                    Group group = GroupLocalServiceUtil.getGroup(groupId);
2507    
2508                    long parentGroupId = groupId;
2509    
2510                    if (group.isLayout()) {
2511                            parentGroupId = group.getParentGroupId();
2512                    }
2513    
2514                    return parentGroupId;
2515            }
2516    
2517            public String getPathContext() {
2518                    return _pathContext;
2519            }
2520    
2521            public String getPathFriendlyURLPrivateGroup() {
2522                    return _pathFriendlyURLPrivateGroup;
2523            }
2524    
2525            public String getPathFriendlyURLPrivateUser() {
2526                    return _pathFriendlyURLPrivateUser;
2527            }
2528    
2529            public String getPathFriendlyURLPublic() {
2530                    return _pathFriendlyURLPublic;
2531            }
2532    
2533            public String getPathImage() {
2534                    return _pathImage;
2535            }
2536    
2537            public String getPathMain() {
2538                    return _pathMain;
2539            }
2540    
2541            public String getPathProxy() {
2542                    return _pathProxy;
2543            }
2544    
2545            public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
2546                    if (Validator.isNull(friendlyURL)) {
2547                            return LayoutConstants.DEFAULT_PLID;
2548                    }
2549    
2550                    String[] urlParts = friendlyURL.split("\\/", 4);
2551    
2552                    if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
2553                            (urlParts.length != 4)) {
2554    
2555                            return LayoutConstants.DEFAULT_PLID;
2556                    }
2557    
2558                    boolean privateLayout = true;
2559    
2560                    String urlPrefix = StringPool.SLASH + urlParts[1];
2561    
2562                    if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
2563                            privateLayout = false;
2564                    }
2565                    else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
2566                                     _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
2567    
2568                            privateLayout = true;
2569                    }
2570                    else {
2571                            return LayoutConstants.DEFAULT_PLID;
2572                    }
2573    
2574                    Group group = null;
2575    
2576                    try {
2577                            group = GroupLocalServiceUtil.getFriendlyURLGroup(
2578                                    companyId, StringPool.SLASH + urlParts[2]);
2579                    }
2580                    catch (Exception e) {
2581                    }
2582    
2583                    if (group != null) {
2584                            Layout layout = null;
2585    
2586                            try {
2587                                    String layoutFriendlyURL = null;
2588    
2589                                    if (urlParts.length == 4) {
2590                                            layoutFriendlyURL = StringPool.SLASH + urlParts[3];
2591    
2592                                            layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2593                                                    group.getGroupId(), privateLayout, layoutFriendlyURL);
2594                                    }
2595                                    else {
2596                                            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2597                                                    group.getGroupId(), privateLayout,
2598                                                    LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
2599    
2600                                            if (!layouts.isEmpty()) {
2601                                                    layout = layouts.get(0);
2602                                            }
2603                                            else {
2604                                                    return LayoutConstants.DEFAULT_PLID;
2605                                            }
2606                                    }
2607    
2608                                    return layout.getPlid();
2609                            }
2610                            catch (Exception e) {
2611                            }
2612                    }
2613    
2614                    return LayoutConstants.DEFAULT_PLID;
2615            }
2616    
2617            public long getPlidFromPortletId(
2618                            long groupId, boolean privateLayout, String portletId)
2619                    throws PortalException, SystemException {
2620    
2621                    long plid = LayoutConstants.DEFAULT_PLID;
2622    
2623                    StringBundler sb = new StringBundler(5);
2624    
2625                    sb.append(groupId);
2626                    sb.append(StringPool.SPACE);
2627                    sb.append(privateLayout);
2628                    sb.append(StringPool.SPACE);
2629                    sb.append(portletId);
2630    
2631                    String key = sb.toString();
2632    
2633                    Long plidObj = _plidToPortletIdMap.get(key);
2634    
2635                    if (plidObj == null) {
2636                            plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
2637    
2638                            if (plid != LayoutConstants.DEFAULT_PLID) {
2639                                    _plidToPortletIdMap.put(key, plid);
2640                            }
2641                    }
2642                    else {
2643                            plid = plidObj.longValue();
2644    
2645                            boolean validPlid = false;
2646    
2647                            try {
2648                                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2649    
2650                                    LayoutTypePortlet layoutTypePortlet =
2651                                            (LayoutTypePortlet)layout.getLayoutType();
2652    
2653                                    if (layoutTypePortlet.hasDefaultScopePortletId(
2654                                                    groupId, portletId)) {
2655    
2656                                            validPlid = true;
2657                                    }
2658                            }
2659                            catch (Exception e) {
2660                            }
2661    
2662                            if (!validPlid) {
2663                                    _plidToPortletIdMap.remove(key);
2664    
2665                                    plid = doGetPlidFromPortletId(
2666                                            groupId, privateLayout, portletId);
2667    
2668                                    if (plid != LayoutConstants.DEFAULT_PLID) {
2669                                            _plidToPortletIdMap.put(key, plid);
2670                                    }
2671                            }
2672                    }
2673    
2674                    return plid;
2675            }
2676    
2677            public long getPlidFromPortletId(long groupId, String portletId)
2678                    throws PortalException, SystemException {
2679    
2680                    long plid = getPlidFromPortletId(groupId, false, portletId);
2681    
2682                    if (plid == LayoutConstants.DEFAULT_PLID) {
2683                            plid = getPlidFromPortletId(groupId, true, portletId);
2684                    }
2685    
2686                    if (plid == LayoutConstants.DEFAULT_PLID) {
2687                            if (_log.isDebugEnabled()) {
2688                                    _log.debug(
2689                                            "Portlet " + portletId +
2690                                                    " does not exist on a page in group " + groupId);
2691                            }
2692                    }
2693    
2694                    return plid;
2695            }
2696    
2697            public String getPortalLibDir() {
2698                    return PropsValues.LIFERAY_LIB_PORTAL_DIR;
2699            }
2700    
2701            /**
2702             * @deprecated {@link #getPortalPort(boolean)}
2703             */
2704            public int getPortalPort() {
2705                    return _portalPort.get();
2706            }
2707    
2708            public int getPortalPort(boolean secure) {
2709                    if (secure) {
2710                            return _securePortalPort.get();
2711                    }
2712                    else {
2713                            return _portalPort.get();
2714                    }
2715            }
2716    
2717            public Properties getPortalProperties() {
2718                    return PropsUtil.getProperties();
2719            }
2720    
2721            public String getPortalURL(HttpServletRequest request) {
2722                    return getPortalURL(request, isSecure(request));
2723            }
2724    
2725            public String getPortalURL(HttpServletRequest request, boolean secure) {
2726                    return getPortalURL(
2727                            request.getServerName(), request.getServerPort(), secure);
2728            }
2729    
2730            public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
2731                    throws PortalException, SystemException {
2732    
2733                    String serverName = themeDisplay.getServerName();
2734    
2735                    if (layout == null) {
2736                            layout = themeDisplay.getLayout();
2737                    }
2738    
2739                    if (layout != null) {
2740                            LayoutSet layoutSet = layout.getLayoutSet();
2741    
2742                            String virtualHostname = layoutSet.getVirtualHostname();
2743    
2744                            if (Validator.isNotNull(virtualHostname)) {
2745                                    serverName = virtualHostname;
2746                            }
2747                    }
2748    
2749                    return getPortalURL(
2750                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
2751            }
2752    
2753            public String getPortalURL(PortletRequest portletRequest) {
2754                    return getPortalURL(portletRequest, portletRequest.isSecure());
2755            }
2756    
2757            public String getPortalURL(PortletRequest portletRequest, boolean secure) {
2758                    return getPortalURL(
2759                            portletRequest.getServerName(), portletRequest.getServerPort(),
2760                            secure);
2761            }
2762    
2763            public String getPortalURL(
2764                    String serverName, int serverPort, boolean secure) {
2765    
2766                    StringBundler sb = new StringBundler();
2767    
2768                    if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
2769                            sb.append(Http.HTTPS_WITH_SLASH);
2770                    }
2771                    else {
2772                            sb.append(Http.HTTP_WITH_SLASH);
2773                    }
2774    
2775                    if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
2776                            sb.append(serverName);
2777                    }
2778                    else {
2779                            sb.append(PropsValues.WEB_SERVER_HOST);
2780                    }
2781    
2782                    if (!secure) {
2783                            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
2784                                    if ((serverPort != Http.HTTP_PORT) &&
2785                                            (serverPort != Http.HTTPS_PORT)) {
2786    
2787                                            sb.append(StringPool.COLON);
2788                                            sb.append(serverPort);
2789                                    }
2790                            }
2791                            else {
2792                                    if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
2793                                            sb.append(StringPool.COLON);
2794                                            sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
2795                                    }
2796                            }
2797                    }
2798    
2799                    if (secure) {
2800                            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
2801                                    if ((serverPort != Http.HTTP_PORT) &&
2802                                            (serverPort != Http.HTTPS_PORT)) {
2803    
2804                                            sb.append(StringPool.COLON);
2805                                            sb.append(serverPort);
2806                                    }
2807                            }
2808                            else {
2809                                    if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
2810                                            sb.append(StringPool.COLON);
2811                                            sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
2812                                    }
2813                            }
2814                    }
2815    
2816                    return sb.toString();
2817            }
2818    
2819            public String getPortalURL(ThemeDisplay themeDisplay)
2820                    throws PortalException, SystemException {
2821    
2822                    return getPortalURL(null, themeDisplay);
2823            }
2824    
2825            public String getPortalWebDir() {
2826                    return PropsValues.LIFERAY_WEB_PORTAL_DIR;
2827            }
2828    
2829            public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
2830                    return _portletAddDefaultResourceCheckWhitelist;
2831            }
2832    
2833            public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
2834                    return _portletAddDefaultResourceCheckWhitelistActions;
2835            }
2836    
2837            /**
2838             * @deprecated {@link #getPortletBreadcrumbs(HttpServletRequest)}
2839             */
2840            public List<BreadcrumbEntry> getPortletBreadcrumbList(
2841                    HttpServletRequest request) {
2842    
2843                    return getPortletBreadcrumbs(request);
2844            }
2845    
2846            public List<BreadcrumbEntry> getPortletBreadcrumbs(
2847                    HttpServletRequest request) {
2848    
2849                    return (List<BreadcrumbEntry>)request.getAttribute(
2850                            WebKeys.PORTLET_BREADCRUMBS);
2851            }
2852    
2853            public String getPortletDescription(
2854                    Portlet portlet, ServletContext servletContext, Locale locale) {
2855    
2856                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
2857                            portlet, servletContext);
2858    
2859                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
2860    
2861                    return resourceBundle.getString(
2862                            JavaConstants.JAVAX_PORTLET_DESCRIPTION);
2863            }
2864    
2865            public String getPortletDescription(Portlet portlet, User user) {
2866                    return getPortletDescription(portlet.getPortletId(), user);
2867            }
2868    
2869            public String getPortletDescription(String portletId, Locale locale) {
2870                    return LanguageUtil.get(
2871                            locale,
2872                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2873                                    StringPool.PERIOD).concat(portletId));
2874            }
2875    
2876            public String getPortletDescription(String portletId, String languageId) {
2877                    Locale locale = LocaleUtil.fromLanguageId(languageId);
2878    
2879                    return getPortletDescription(portletId, locale);
2880            }
2881    
2882            public String getPortletDescription(String portletId, User user) {
2883                    return LanguageUtil.get(
2884                            user.getLocale(),
2885                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2886                                    StringPool.PERIOD).concat(portletId));
2887            }
2888    
2889            public Object[] getPortletFriendlyURLMapper(
2890                            long groupId, boolean privateLayout, String url,
2891                            Map<String, String[]> params, Map<String, Object> requestContext)
2892                    throws PortalException, SystemException {
2893    
2894                    boolean foundFriendlyURLMapper = false;
2895    
2896                    String friendlyURL = url;
2897                    String queryString = StringPool.BLANK;
2898    
2899                    List<Portlet> portlets =
2900                            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
2901    
2902                    Iterator<Portlet> itr = portlets.iterator();
2903    
2904                    while (itr.hasNext()) {
2905                            Portlet portlet = itr.next();
2906    
2907                            FriendlyURLMapper friendlyURLMapper =
2908                                    portlet.getFriendlyURLMapperInstance();
2909    
2910                            if (url.endsWith(
2911                                            StringPool.SLASH + friendlyURLMapper.getMapping())) {
2912    
2913                                    url += StringPool.SLASH;
2914                            }
2915    
2916                            int pos = -1;
2917    
2918                            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2919                                    pos = url.indexOf(
2920                                            FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
2921                                                    StringPool.SLASH);
2922                            }
2923                            else {
2924                                    pos = url.indexOf(
2925                                            StringPool.SLASH + friendlyURLMapper.getMapping() +
2926                                                    StringPool.SLASH);
2927                            }
2928    
2929                            if (pos != -1) {
2930                                    foundFriendlyURLMapper = true;
2931    
2932                                    friendlyURL = url.substring(0, pos);
2933    
2934                                    InheritableMap<String, String[]> actualParams =
2935                                            new InheritableMap<String, String[]>();
2936    
2937                                    if (params != null) {
2938                                            actualParams.setParentMap(params);
2939                                    }
2940    
2941                                    Map<String, String> prpIdentifiers =
2942                                            new HashMap<String, String>();
2943    
2944                                    Set<PublicRenderParameter> publicRenderParameters =
2945                                            portlet.getPublicRenderParameters();
2946    
2947                                    for (PublicRenderParameter publicRenderParameter :
2948                                                    publicRenderParameters) {
2949    
2950                                            QName qName = publicRenderParameter.getQName();
2951    
2952                                            String publicRenderParameterIdentifier =
2953                                                    qName.getLocalPart();
2954                                            String publicRenderParameterName =
2955                                                    PortletQNameUtil.getPublicRenderParameterName(qName);
2956    
2957                                            prpIdentifiers.put(
2958                                                    publicRenderParameterIdentifier,
2959                                                    publicRenderParameterName);
2960                                    }
2961    
2962                                    FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
2963    
2964                                    if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2965                                            friendlyURLMapper.populateParams(
2966                                                    url.substring(pos + 2), actualParams,
2967                                                    requestContext);
2968                                    }
2969                                    else {
2970                                            friendlyURLMapper.populateParams(
2971                                                    url.substring(pos), actualParams, requestContext);
2972                                    }
2973    
2974                                    queryString =
2975                                            StringPool.AMPERSAND +
2976                                                    HttpUtil.parameterMapToString(actualParams, false);
2977    
2978                                    break;
2979                            }
2980                    }
2981    
2982                    if (!foundFriendlyURLMapper) {
2983                            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
2984    
2985                            if (x != -1) {
2986                                    int y = url.indexOf(CharPool.SLASH, x + 3);
2987    
2988                                    if (y == -1) {
2989                                            y = url.length();
2990                                    }
2991    
2992                                    String ppid = url.substring(x + 3, y);
2993    
2994                                    if (Validator.isNotNull(ppid)) {
2995                                            friendlyURL = url.substring(0, x);
2996    
2997                                            Map<String, String[]> actualParams = null;
2998    
2999                                            if (params != null) {
3000                                                    actualParams = new HashMap<String, String[]>(params);
3001                                            }
3002                                            else {
3003                                                    actualParams = new HashMap<String, String[]>();
3004                                            }
3005    
3006                                            actualParams.put("p_p_id", new String[] {ppid});
3007                                            actualParams.put("p_p_lifecycle", new String[] {"0"});
3008                                            actualParams.put(
3009                                                    "p_p_state",
3010                                                    new String[] {WindowState.MAXIMIZED.toString()});
3011                                            actualParams.put(
3012                                                    "p_p_mode", new String[] {PortletMode.VIEW.toString()});
3013    
3014                                            queryString =
3015                                                    StringPool.AMPERSAND +
3016                                                            HttpUtil.parameterMapToString(actualParams, false);
3017                                    }
3018                            }
3019                    }
3020    
3021                    friendlyURL = StringUtil.replace(
3022                            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3023    
3024                    if (friendlyURL.endsWith(StringPool.SLASH)) {
3025                            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
3026                    }
3027    
3028                    Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3029                            groupId, privateLayout, friendlyURL);
3030    
3031                    return new Object[] {layout, queryString};
3032            }
3033    
3034            public String getPortletId(HttpServletRequest request) {
3035                    PortletConfigImpl portletConfigImpl =
3036                            (PortletConfigImpl)request.getAttribute(
3037                                    JavaConstants.JAVAX_PORTLET_CONFIG);
3038    
3039                    if (portletConfigImpl != null) {
3040                            return portletConfigImpl.getPortletId();
3041                    }
3042                    else {
3043                            return null;
3044                    }
3045            }
3046    
3047            public String getPortletId(PortletRequest portletRequest) {
3048                    PortletConfigImpl portletConfigImpl =
3049                            (PortletConfigImpl)portletRequest.getAttribute(
3050                                    JavaConstants.JAVAX_PORTLET_CONFIG);
3051    
3052                    if (portletConfigImpl != null) {
3053                            return portletConfigImpl.getPortletId();
3054                    }
3055                    else {
3056                            return null;
3057                    }
3058            }
3059    
3060            public String getPortletLongTitle(Portlet portlet, Locale locale) {
3061                    return getPortletLongTitle(portlet.getPortletId(), locale);
3062            }
3063    
3064            public String getPortletLongTitle(
3065                    Portlet portlet, ServletContext servletContext, Locale locale) {
3066    
3067                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3068                            portlet, servletContext);
3069    
3070                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3071    
3072                    try {
3073                            String portletLongTitle = resourceBundle.getString(
3074                                    JavaConstants.JAVAX_PORTLET_LONG_TITLE);
3075    
3076                            if (portletLongTitle.startsWith(
3077                                            JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
3078    
3079                                    portletLongTitle = getPortletTitle(
3080                                            portlet, servletContext, locale);
3081                            }
3082    
3083                            return portletLongTitle;
3084                    }
3085                    catch (Exception e) {
3086                            return getPortletTitle(portlet, servletContext, locale);
3087                    }
3088            }
3089    
3090            public String getPortletLongTitle(Portlet portlet, String languageId) {
3091                    return getPortletLongTitle(portlet.getPortletId(), languageId);
3092            }
3093    
3094            public String getPortletLongTitle(Portlet portlet, User user) {
3095                    return getPortletLongTitle(portlet.getPortletId(), user);
3096            }
3097    
3098            public String getPortletLongTitle(String portletId, Locale locale) {
3099                    String portletLongTitle = LanguageUtil.get(
3100                            locale,
3101                            JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
3102                                    StringPool.PERIOD).concat(portletId),
3103                            StringPool.BLANK);
3104    
3105                    if (Validator.isNull(portletLongTitle)) {
3106                            portletLongTitle = getPortletTitle(portletId, locale);
3107                    }
3108    
3109                    return portletLongTitle;
3110            }
3111    
3112            public String getPortletLongTitle(String portletId, String languageId) {
3113                    Locale locale = LocaleUtil.fromLanguageId(languageId);
3114    
3115                    return getPortletLongTitle(portletId, locale);
3116            }
3117    
3118            public String getPortletLongTitle(String portletId, User user) {
3119                    return getPortletLongTitle(portletId, user.getLocale());
3120            }
3121    
3122            public String getPortletNamespace(String portletId) {
3123                    return StringPool.UNDERLINE.concat(portletId).concat(
3124                            StringPool.UNDERLINE);
3125            }
3126    
3127            public String getPortletTitle(Portlet portlet, Locale locale) {
3128                    return getPortletTitle(portlet.getPortletId(), locale);
3129            }
3130    
3131            public String getPortletTitle(
3132                    Portlet portlet, ServletContext servletContext, Locale locale) {
3133    
3134                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3135                            portlet, servletContext);
3136    
3137                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3138    
3139                    return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
3140            }
3141    
3142            public String getPortletTitle(Portlet portlet, String languageId) {
3143                    return getPortletTitle(portlet.getPortletId(), languageId);
3144            }
3145    
3146            public String getPortletTitle(Portlet portlet, User user) {
3147                    return getPortletTitle(portlet.getPortletId(), user);
3148            }
3149    
3150            public String getPortletTitle(RenderResponse renderResponse) {
3151                    PortletResponseImpl portletResponseImpl =
3152                            PortletResponseImpl.getPortletResponseImpl(renderResponse);
3153    
3154                    return ((RenderResponseImpl)portletResponseImpl).getTitle();
3155            }
3156    
3157            public String getPortletTitle(String portletId, Locale locale) {
3158                    return LanguageUtil.get(
3159                            locale,
3160                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
3161                                    portletId));
3162            }
3163    
3164            public String getPortletTitle(String portletId, String languageId) {
3165                    Locale locale = LocaleUtil.fromLanguageId(languageId);
3166    
3167                    return getPortletTitle(portletId, locale);
3168            }
3169    
3170            public String getPortletTitle(String portletId, User user) {
3171                    return LanguageUtil.get(
3172                            user.getLocale(),
3173                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
3174                                    portletId));
3175            }
3176    
3177            public String getPortletXmlFileName() throws SystemException {
3178                    if (PrefsPropsUtil.getBoolean(
3179                                    PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
3180                                    PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
3181    
3182                            return PORTLET_XML_FILE_NAME_CUSTOM;
3183                    }
3184                    else {
3185                            return PORTLET_XML_FILE_NAME_STANDARD;
3186                    }
3187            }
3188    
3189            public PortletPreferences getPreferences(HttpServletRequest request) {
3190                    RenderRequest renderRequest = (RenderRequest)request.getAttribute(
3191                            JavaConstants.JAVAX_PORTLET_REQUEST);
3192    
3193                    PortletPreferences portletPreferences = null;
3194    
3195                    if (renderRequest != null) {
3196                            PortletPreferencesWrapper portletPreferencesWrapper =
3197                                    (PortletPreferencesWrapper)renderRequest.getPreferences();
3198    
3199                            portletPreferences =
3200                                    portletPreferencesWrapper.getPortletPreferencesImpl();
3201                    }
3202    
3203                    return portletPreferences;
3204            }
3205    
3206            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
3207                    PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
3208    
3209                    return portletBag.getPreferencesValidatorInstance();
3210            }
3211    
3212            public String getRelativeHomeURL(HttpServletRequest request)
3213                    throws PortalException, SystemException {
3214    
3215                    Company company = getCompany(request);
3216    
3217                    String homeURL = company.getHomeURL();
3218    
3219                    if (Validator.isNull(homeURL)) {
3220                            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
3221                    }
3222    
3223                    return homeURL;
3224            }
3225    
3226            public long getScopeGroupId(HttpServletRequest request)
3227                    throws PortalException, SystemException {
3228    
3229                    String portletId = getPortletId(request);
3230    
3231                    return getScopeGroupId(request, portletId);
3232            }
3233    
3234            public long getScopeGroupId(HttpServletRequest request, String portletId)
3235                    throws PortalException, SystemException {
3236    
3237                    return getScopeGroupId(request, portletId, false);
3238            }
3239    
3240            public long getScopeGroupId(
3241                            HttpServletRequest request, String portletId,
3242                            boolean checkStagingGroup)
3243                    throws PortalException, SystemException {
3244    
3245                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3246    
3247                    long scopeGroupId = 0;
3248    
3249                    if (layout != null) {
3250                            Group group = layout.getGroup();
3251    
3252                            if (group.isControlPanel()) {
3253                                    long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
3254    
3255                                    Group doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
3256    
3257                                    if ((doAsGroupId <= 0) || (doAsGroup == null)) {
3258                                            doAsGroupId = getDefaultScopeGroupId(group.getCompanyId());
3259                                    }
3260    
3261                                    if (doAsGroupId > 0) {
3262                                            scopeGroupId = doAsGroupId;
3263                                    }
3264    
3265                                    group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
3266    
3267                                    if ((group != null) && group.hasStagingGroup()) {
3268                                            try {
3269                                                    Group stagingGroup = group.getStagingGroup();
3270    
3271                                                    scopeGroupId = stagingGroup.getGroupId();
3272                                            }
3273                                            catch (Exception e) {
3274                                            }
3275                                    }
3276                            }
3277    
3278                            if ((portletId != null) &&
3279                                    (group.isStaged() || group.isStagingGroup())) {
3280    
3281                                    Group liveGroup = group;
3282    
3283                                    if (group.isStagingGroup()) {
3284                                            liveGroup = group.getLiveGroup();
3285                                    }
3286    
3287                                    if (liveGroup.isStaged() &&
3288                                            !liveGroup.isStagedPortlet(portletId)) {
3289    
3290                                            Layout liveGroupLayout =
3291                                                    LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
3292                                                            layout.getUuid(), liveGroup.getGroupId());
3293    
3294                                            if ((liveGroupLayout != null) &&
3295                                                    liveGroupLayout.hasScopeGroup()) {
3296    
3297                                                    scopeGroupId = getScopeGroupId(
3298                                                            liveGroupLayout, portletId);
3299                                            }
3300                                            else if (checkStagingGroup &&
3301                                                             !liveGroup.isStagedRemotely()) {
3302    
3303                                                    Group stagingGroup = liveGroup.getStagingGroup();
3304    
3305                                                    scopeGroupId = stagingGroup.getGroupId();
3306                                            }
3307                                            else {
3308                                                    scopeGroupId = liveGroup.getGroupId();
3309                                            }
3310                                    }
3311                            }
3312                    }
3313    
3314                    if (scopeGroupId <= 0) {
3315                            scopeGroupId = getScopeGroupId(layout, portletId);
3316                    }
3317    
3318                    return scopeGroupId;
3319            }
3320    
3321            public long getScopeGroupId(Layout layout) {
3322                    if (layout == null) {
3323                            return 0;
3324                    }
3325                    else {
3326                            return layout.getGroupId();
3327                    }
3328            }
3329    
3330            public long getScopeGroupId(Layout layout, String portletId) {
3331                    if (layout == null) {
3332                            return 0;
3333                    }
3334    
3335                    if (Validator.isNull(portletId)) {
3336                            return layout.getGroupId();
3337                    }
3338    
3339                    boolean strict = PortletPreferencesThreadLocal.isStrict();
3340    
3341                    PortletPreferencesThreadLocal.setStrict(true);
3342    
3343                    try {
3344                            PortletPreferences portletSetup =
3345                                    PortletPreferencesFactoryUtil.getLayoutPortletSetup(
3346                                            layout, portletId);
3347    
3348                            String scopeType = GetterUtil.getString(
3349                                    portletSetup.getValue("lfrScopeType", null));
3350    
3351                            if (Validator.isNull(scopeType)) {
3352                                    return layout.getGroupId();
3353                            }
3354    
3355                            if (scopeType.equals("company")) {
3356                                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
3357                                            layout.getCompanyId());
3358    
3359                                    return companyGroup.getGroupId();
3360                            }
3361                            else {
3362                                    String scopeLayoutUuid = GetterUtil.getString(
3363                                            portletSetup.getValue("lfrScopeLayoutUuid", null));
3364    
3365                                    Layout scopeLayout =
3366                                            LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
3367                                                    scopeLayoutUuid, layout.getGroupId());
3368    
3369                                    Group scopeGroup = scopeLayout.getScopeGroup();
3370    
3371                                    return scopeGroup.getGroupId();
3372                            }
3373                    }
3374                    catch (Exception e) {
3375                            return layout.getGroupId();
3376                    }
3377                    finally {
3378                            PortletPreferencesThreadLocal.setStrict(strict);
3379                    }
3380            }
3381    
3382            public long getScopeGroupId(long plid) {
3383                    Layout layout = null;
3384    
3385                    try {
3386                            layout = LayoutLocalServiceUtil.getLayout(plid);
3387                    }
3388                    catch (Exception e) {
3389                    }
3390    
3391                    return getScopeGroupId(layout);
3392            }
3393    
3394            public long getScopeGroupId(PortletRequest portletRequest)
3395                    throws PortalException, SystemException {
3396    
3397                    return getScopeGroupId(getHttpServletRequest(portletRequest));
3398            }
3399    
3400            public User getSelectedUser(HttpServletRequest request)
3401                    throws PortalException, SystemException {
3402    
3403                    return getSelectedUser(request, true);
3404            }
3405    
3406            public User getSelectedUser(
3407                            HttpServletRequest request, boolean checkPermission)
3408                    throws PortalException, SystemException {
3409    
3410                    long userId = ParamUtil.getLong(request, "p_u_i_d");
3411    
3412                    User user = null;
3413    
3414                    try {
3415                            if (checkPermission) {
3416                                    user = UserServiceUtil.getUserById(userId);
3417                            }
3418                            else {
3419                                    user = UserLocalServiceUtil.getUserById(userId);
3420                            }
3421                    }
3422                    catch (NoSuchUserException nsue) {
3423                    }
3424    
3425                    return user;
3426            }
3427    
3428            public User getSelectedUser(PortletRequest portletRequest)
3429                    throws PortalException, SystemException {
3430    
3431                    return getSelectedUser(portletRequest, true);
3432            }
3433    
3434            public User getSelectedUser(
3435                            PortletRequest portletRequest, boolean checkPermission)
3436                    throws PortalException, SystemException {
3437    
3438                    return getSelectedUser(
3439                            getHttpServletRequest(portletRequest), checkPermission);
3440            }
3441    
3442            public ServletContext getServletContext(
3443                    Portlet portlet, ServletContext servletContext) {
3444    
3445                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3446                            portlet, servletContext);
3447    
3448                    PortletContextImpl portletContextImpl =
3449                            (PortletContextImpl)portletConfig.getPortletContext();
3450    
3451                    return portletContextImpl.getServletContext();
3452            }
3453    
3454            public String getSiteLoginURL(ThemeDisplay themeDisplay)
3455                    throws PortalException, SystemException {
3456    
3457                    if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
3458                            return null;
3459                    }
3460    
3461                    List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
3462    
3463                    if (layouts == null) {
3464                            return null;
3465                    }
3466    
3467                    for (Layout layout : layouts) {
3468                            String friendlyURL = layout.getFriendlyURL();
3469    
3470                            if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
3471                                    if (themeDisplay.getLayout() == null) {
3472                                            break;
3473                                    }
3474    
3475                                    String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
3476                                            layout.getLayoutSet(), themeDisplay);
3477    
3478                                    return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
3479                            }
3480                    }
3481    
3482                    return null;
3483            }
3484    
3485            public String getStaticResourceURL(HttpServletRequest request, String uri) {
3486                    return getStaticResourceURL(request, uri, null, 0);
3487            }
3488    
3489            public String getStaticResourceURL(
3490                    HttpServletRequest request, String uri, long timestamp) {
3491    
3492                    return getStaticResourceURL(request, uri, null, timestamp);
3493            }
3494    
3495            public String getStaticResourceURL(
3496                    HttpServletRequest request, String uri, String queryString) {
3497    
3498                    return getStaticResourceURL(request, uri, queryString, 0);
3499            }
3500    
3501            public String getStaticResourceURL(
3502                    HttpServletRequest request, String uri, String queryString,
3503                    long timestamp) {
3504    
3505                    if (uri.indexOf(CharPool.QUESTION) != -1) {
3506                            return uri;
3507                    }
3508    
3509                    if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
3510                            uri = uri.substring(1);
3511                    }
3512    
3513                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3514                            WebKeys.THEME_DISPLAY);
3515    
3516                    Theme theme = themeDisplay.getTheme();
3517                    ColorScheme colorScheme = themeDisplay.getColorScheme();
3518    
3519                    Map<String, String[]> parameterMap = null;
3520    
3521                    if (Validator.isNotNull(queryString)) {
3522                            parameterMap = HttpUtil.getParameterMap(queryString);
3523                    }
3524    
3525                    StringBundler sb = new StringBundler();
3526    
3527                    // URI
3528    
3529                    sb.append(uri);
3530                    sb.append(StringPool.QUESTION);
3531    
3532                    // Browser id
3533    
3534                    if ((parameterMap == null) ||
3535                            (!parameterMap.containsKey("browserId"))) {
3536    
3537                            sb.append("&browserId=");
3538                            sb.append(BrowserSnifferUtil.getBrowserId(request));
3539                    }
3540    
3541                    // Theme and color scheme
3542    
3543                    if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
3544                            ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
3545    
3546                            sb.append("&themeId=");
3547                            sb.append(theme.getThemeId());
3548                    }
3549    
3550                    if (uri.endsWith(".jsp") &&
3551                            ((parameterMap == null) ||
3552                             !parameterMap.containsKey("colorSchemeId"))) {
3553    
3554                            sb.append("&colorSchemeId=");
3555                            sb.append(colorScheme.getColorSchemeId());
3556                    }
3557    
3558                    // Minifier
3559    
3560                    if ((parameterMap == null) ||
3561                            (!parameterMap.containsKey("minifierType"))) {
3562    
3563                            String minifierType = StringPool.BLANK;
3564    
3565                            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
3566                                    uri.matches(".*/css/.*\\.jsp")) {
3567    
3568                                    if (themeDisplay.isThemeCssFastLoad()) {
3569                                            minifierType = "css";
3570                                    }
3571                            }
3572                            else if (themeDisplay.isThemeJsFastLoad()) {
3573                                    minifierType = "js";
3574                            }
3575    
3576                            if (Validator.isNotNull(minifierType)) {
3577                                    sb.append("&minifierType=");
3578                                    sb.append(minifierType);
3579                            }
3580                    }
3581    
3582                    // Query string
3583    
3584                    if (Validator.isNotNull(queryString)) {
3585                            if (!queryString.startsWith(StringPool.AMPERSAND)) {
3586                                    sb.append(StringPool.AMPERSAND);
3587                            }
3588    
3589                            sb.append(queryString);
3590                    }
3591    
3592                    // Language id
3593    
3594                    sb.append("&languageId=");
3595                    sb.append(themeDisplay.getLanguageId());
3596    
3597                    // Build number
3598    
3599                    sb.append("&b=");
3600                    sb.append(ReleaseInfo.getBuildNumber());
3601    
3602                    // Timestamp
3603    
3604                    if ((parameterMap == null) || !parameterMap.containsKey("t")) {
3605                            if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
3606                                    ServletContext servletContext =
3607                                            (ServletContext)request.getAttribute(WebKeys.CTX);
3608    
3609                                    timestamp = FileTimestampUtil.getTimestamp(servletContext, uri);
3610                            }
3611    
3612                            if (timestamp == 0) {
3613                                    timestamp = theme.getTimestamp();
3614                            }
3615    
3616                            sb.append("&t=");
3617                            sb.append(timestamp);
3618                    }
3619    
3620                    String url = sb.toString();
3621    
3622                    url = StringUtil.replace(url, "?&", StringPool.QUESTION);
3623    
3624                    return url;
3625            }
3626    
3627            public String getStrutsAction(HttpServletRequest request) {
3628                    String strutsAction = ParamUtil.getString(request, "struts_action");
3629    
3630                    if (Validator.isNotNull(strutsAction)) {
3631    
3632                            // This method should only return a Struts action if you're dealing
3633                            // with a regular HTTP servlet request, not a portlet HTTP servlet
3634                            // request.
3635    
3636                            return StringPool.BLANK;
3637                    }
3638    
3639                    return getPortletParam(request, "struts_action");
3640            }
3641    
3642            public String[] getSystemGroups() {
3643                    return _allSystemGroups;
3644            }
3645    
3646            public String[] getSystemOrganizationRoles() {
3647                    return _allSystemOrganizationRoles;
3648            }
3649    
3650            public String[] getSystemRoles() {
3651                    return _allSystemRoles;
3652            }
3653    
3654            public String[] getSystemSiteRoles() {
3655                    return _allSystemSiteRoles;
3656            }
3657    
3658            public UploadPortletRequest getUploadPortletRequest(
3659                    PortletRequest portletRequest) {
3660    
3661                    PortletRequestImpl portletRequestImpl =
3662                            (PortletRequestImpl)portletRequest;
3663    
3664                    DynamicServletRequest dynamicRequest =
3665                            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
3666    
3667                    HttpServletRequestWrapper requestWrapper =
3668                            (HttpServletRequestWrapper)dynamicRequest.getRequest();
3669    
3670                    UploadServletRequest uploadServletRequest = getUploadServletRequest(
3671                            requestWrapper);
3672    
3673                    return new UploadPortletRequestImpl(
3674                            uploadServletRequest,
3675                            getPortletNamespace(portletRequestImpl.getPortletName()));
3676            }
3677    
3678            public UploadServletRequest getUploadServletRequest(
3679                    HttpServletRequest request) {
3680    
3681                    HttpServletRequestWrapper requestWrapper = null;
3682    
3683                    if (request instanceof HttpServletRequestWrapper) {
3684                            requestWrapper = (HttpServletRequestWrapper)request;
3685                    }
3686    
3687                    UploadServletRequest uploadServletRequest = null;
3688    
3689                    while (uploadServletRequest == null) {
3690    
3691                            // Find the underlying UploadServletRequest wrapper. For example,
3692                            // WebSphere wraps all requests with ProtectedServletRequest.
3693    
3694                            if (requestWrapper instanceof UploadServletRequest) {
3695                                    uploadServletRequest = (UploadServletRequest)requestWrapper;
3696                            }
3697                            else {
3698                                    HttpServletRequest parentRequest =
3699                                            (HttpServletRequest)requestWrapper.getRequest();
3700    
3701                                    if (!(parentRequest instanceof HttpServletRequestWrapper)) {
3702    
3703                                            // This block should never be reached unless this method is
3704                                            // called from a hot deployable portlet. See LayoutAction.
3705    
3706                                            uploadServletRequest = new UploadServletRequestImpl(
3707                                                    parentRequest);
3708    
3709                                            break;
3710                                    }
3711                                    else {
3712                                            requestWrapper = (HttpServletRequestWrapper)parentRequest;
3713                                    }
3714                            }
3715                    }
3716    
3717                    return uploadServletRequest;
3718            }
3719    
3720            public Date getUptime() {
3721                    return _upTime;
3722            }
3723    
3724            public String getURLWithSessionId(String url, String sessionId) {
3725                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
3726                            return url;
3727                    }
3728    
3729                    if (Validator.isNull(url)) {
3730                            return url;
3731                    }
3732    
3733                    // LEP-4787
3734    
3735                    int x = url.indexOf(CharPool.SEMICOLON);
3736    
3737                    if (x != -1) {
3738                            return url;
3739                    }
3740    
3741                    x = url.indexOf(CharPool.QUESTION);
3742    
3743                    if (x != -1) {
3744                            StringBundler sb = new StringBundler(4);
3745    
3746                            sb.append(url.substring(0, x));
3747                            sb.append(_JSESSIONID);
3748                            sb.append(sessionId);
3749                            sb.append(url.substring(x));
3750    
3751                            return sb.toString();
3752                    }
3753    
3754                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
3755                    // http://www.abc.com/;jsessionid=XYZ does work.
3756    
3757                    x = url.indexOf(StringPool.DOUBLE_SLASH);
3758    
3759                    StringBundler sb = new StringBundler(4);
3760    
3761                    sb.append(url);
3762    
3763                    if (x != -1) {
3764                            int y = url.lastIndexOf(CharPool.SLASH);
3765    
3766                            if (x + 1 == y) {
3767                                    sb.append(StringPool.SLASH);
3768                            }
3769                    }
3770    
3771                    sb.append(_JSESSIONID);
3772                    sb.append(sessionId);
3773    
3774                    return sb.toString();
3775            }
3776    
3777            public User getUser(HttpServletRequest request)
3778                    throws PortalException, SystemException {
3779    
3780                    User user = (User)request.getAttribute(WebKeys.USER);
3781    
3782                    if (user != null) {
3783                            return user;
3784                    }
3785    
3786                    long userId = getUserId(request);
3787    
3788                    if (userId <= 0) {
3789    
3790                            // Portlet WARs may have the correct remote user and not have the
3791                            // correct user id because the user id is saved in the session
3792                            // and may not be accessible by the portlet WAR's session. This
3793                            // behavior is inconsistent across different application servers.
3794    
3795                            String remoteUser = request.getRemoteUser();
3796    
3797                            if (remoteUser == null) {
3798                                    return null;
3799                            }
3800    
3801                            userId = GetterUtil.getLong(remoteUser);
3802                    }
3803    
3804                    user = UserLocalServiceUtil.getUserById(userId);
3805    
3806                    request.setAttribute(WebKeys.USER, user);
3807    
3808                    return user;
3809            }
3810    
3811            public User getUser(PortletRequest portletRequest)
3812                    throws PortalException, SystemException {
3813    
3814                    return getUser(getHttpServletRequest(portletRequest));
3815            }
3816    
3817            public String getUserEmailAddress(long userId) throws SystemException {
3818                    try {
3819                            User user = UserLocalServiceUtil.getUserById(userId);
3820    
3821                            return user.getEmailAddress();
3822                    }
3823                    catch (PortalException pe) {
3824                            return StringPool.BLANK;
3825                    }
3826            }
3827    
3828            public long getUserId(HttpServletRequest request) {
3829                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
3830    
3831                    if (userIdObj != null) {
3832                            return userIdObj.longValue();
3833                    }
3834    
3835                    String path = GetterUtil.getString(request.getPathInfo());
3836                    String strutsAction = getStrutsAction(request);
3837                    String actionName = getPortletParam(request, "actionName");
3838    
3839                    boolean alwaysAllowDoAsUser = false;
3840    
3841                    if (path.equals("/portal/session_click") ||
3842                            strutsAction.equals("/document_library/edit_file_entry") ||
3843                            strutsAction.equals("/document_library_display/edit_file_entry") ||
3844                            strutsAction.equals("/image_gallery_display/edit_file_entry") ||
3845                            strutsAction.equals("/image_gallery_display/edit_image") ||
3846                            strutsAction.equals("/wiki/edit_page_attachment") ||
3847                            strutsAction.equals("/wiki_admin/edit_page_attachment") ||
3848                            actionName.equals("addFile")) {
3849    
3850                            try {
3851                                    alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
3852                            }
3853                            catch (Exception e) {
3854                                    _log.error(e, e);
3855                            }
3856                    }
3857    
3858                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
3859                              PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
3860                            (alwaysAllowDoAsUser)) {
3861    
3862                            String doAsUserIdString = ParamUtil.getString(
3863                                    request, "doAsUserId");
3864    
3865                            try {
3866                                    long doAsUserId = getDoAsUserId(
3867                                            request, doAsUserIdString, alwaysAllowDoAsUser);
3868    
3869                                    if (doAsUserId > 0) {
3870                                            if (_log.isDebugEnabled()) {
3871                                                    _log.debug("Impersonating user " + doAsUserId);
3872                                            }
3873    
3874                                            return doAsUserId;
3875                                    }
3876                            }
3877                            catch (Exception e) {
3878                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
3879                            }
3880                    }
3881    
3882                    HttpSession session = request.getSession();
3883    
3884                    String jRemoteUser = null;
3885    
3886                    if (PropsValues.PORTAL_JAAS_ENABLE) {
3887                            jRemoteUser = (String)session.getAttribute("j_remoteuser");
3888                    }
3889    
3890                    if (Validator.isNotNull(jRemoteUser)) {
3891                            userIdObj = GetterUtil.getLong(jRemoteUser);
3892                    }
3893                    else {
3894                            userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
3895                    }
3896    
3897                    if (userIdObj != null) {
3898                            request.setAttribute(WebKeys.USER_ID, userIdObj);
3899    
3900                            return userIdObj.longValue();
3901                    }
3902                    else {
3903                            return 0;
3904                    }
3905            }
3906    
3907            public long getUserId(PortletRequest portletRequest) {
3908                    return getUserId(getHttpServletRequest(portletRequest));
3909            }
3910    
3911            public String getUserName(long userId, String defaultUserName) {
3912                    return getUserName(
3913                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
3914            }
3915    
3916            public String getUserName(
3917                    long userId, String defaultUserName, HttpServletRequest request) {
3918    
3919                    return getUserName(
3920                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
3921            }
3922    
3923            public String getUserName(
3924                    long userId, String defaultUserName, String userAttribute) {
3925    
3926                    return getUserName(userId, defaultUserName, userAttribute, null);
3927            }
3928    
3929            public String getUserName(
3930                    long userId, String defaultUserName, String userAttribute,
3931                    HttpServletRequest request) {
3932    
3933                    String userName = defaultUserName;
3934    
3935                    try {
3936                            User user = UserLocalServiceUtil.getUserById(userId);
3937    
3938                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
3939                                    userName = user.getFullName();
3940                            }
3941                            else {
3942                                    userName = user.getScreenName();
3943                            }
3944    
3945                            if (request != null) {
3946                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3947    
3948                                    PortletURL portletURL = new PortletURLImpl(
3949                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
3950                                            PortletRequest.RENDER_PHASE);
3951    
3952                                    portletURL.setWindowState(WindowState.MAXIMIZED);
3953                                    portletURL.setPortletMode(PortletMode.VIEW);
3954    
3955                                    portletURL.setParameter(
3956                                            "struts_action", "/directory/view_user");
3957                                    portletURL.setParameter(
3958                                            "p_u_i_d", String.valueOf(user.getUserId()));
3959    
3960                                    userName =
3961                                            "<a href=\"" + portletURL.toString() + "\">" +
3962                                                    HtmlUtil.escape(userName) + "</a>";
3963                            }
3964                    }
3965                    catch (Exception e) {
3966                    }
3967    
3968                    return userName;
3969            }
3970    
3971            public String getUserPassword(HttpServletRequest request) {
3972                    HttpSession session = request.getSession();
3973    
3974                    return getUserPassword(session);
3975            }
3976    
3977            public String getUserPassword(HttpSession session) {
3978                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
3979            }
3980    
3981            public String getUserPassword(PortletRequest portletRequest) {
3982                    return getUserPassword(getHttpServletRequest(portletRequest));
3983            }
3984    
3985            public String getUserValue(long userId, String param, String defaultValue)
3986                    throws SystemException {
3987    
3988                    if (Validator.isNotNull(defaultValue)) {
3989                            return defaultValue;
3990                    }
3991                    else {
3992                            try {
3993                                    User user = UserLocalServiceUtil.getUserById(userId);
3994    
3995                                    return BeanPropertiesUtil.getString(user, param, defaultValue);
3996                            }
3997                            catch (PortalException pe) {
3998                                    return StringPool.BLANK;
3999                            }
4000                    }
4001            }
4002    
4003            public long getValidUserId(long companyId, long userId)
4004                    throws PortalException, SystemException {
4005    
4006                    try {
4007                            User user = UserLocalServiceUtil.getUser(userId);
4008    
4009                            if (user.getCompanyId() == companyId) {
4010                                    return user.getUserId();
4011                            }
4012                            else {
4013                                    return userId;
4014                            }
4015                    }
4016                    catch (NoSuchUserException nsue) {
4017                            return UserLocalServiceUtil.getDefaultUserId(companyId);
4018                    }
4019            }
4020    
4021            public String getVirtualLayoutActualURL(
4022                            long groupId, boolean privateLayout, String mainPath,
4023                            String friendlyURL, Map<String, String[]> params,
4024                            Map<String, Object> requestContext)
4025                    throws PortalException, SystemException {
4026    
4027                    // Group friendly URL
4028    
4029                    String groupFriendlyURL = null;
4030    
4031                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
4032    
4033                    if (pos != -1) {
4034                            groupFriendlyURL = friendlyURL.substring(2, pos);
4035                    }
4036    
4037                    if (Validator.isNull(groupFriendlyURL)) {
4038                            return mainPath;
4039                    }
4040    
4041                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
4042                            "request");
4043    
4044                    long companyId = PortalInstances.getCompanyId(request);
4045    
4046                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
4047                            companyId, groupFriendlyURL);
4048    
4049                    if (group == null) {
4050                            return mainPath;
4051                    }
4052    
4053                    // Layout friendly URL
4054    
4055                    String layoutFriendlyURL = null;
4056    
4057                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
4058                            layoutFriendlyURL = friendlyURL.substring(
4059                                    pos, friendlyURL.length());
4060                    }
4061    
4062                    if (Validator.isNull(layoutFriendlyURL)) {
4063                            return mainPath;
4064                    }
4065    
4066                    String actualURL = getActualURL(
4067                            group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
4068                            params, requestContext);
4069    
4070                    return HttpUtil.addParameter(
4071                            HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
4072                            groupId);
4073            }
4074    
4075            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
4076                    throws PortalException, SystemException {
4077    
4078                    return getServletURL(
4079                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
4080            }
4081    
4082            public void initCustomSQL() {
4083                    _customSqlKeys = new String[] {
4084                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
4085                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
4086                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
4087                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
4088                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
4089                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
4090                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
4091                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
4092                                    "BOOKMARKSENTRY$]",
4093                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
4094                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
4095                                    "DLFILEENTRY$]",
4096                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4097                                    "MBMESSAGE$]",
4098                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4099                                    "MBTHREAD$]",
4100                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
4101                            "[$RESOURCE_SCOPE_COMPANY$]",
4102                            "[$RESOURCE_SCOPE_GROUP$]",
4103                            "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
4104                            "[$RESOURCE_SCOPE_INDIVIDUAL$]",
4105                            "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
4106                            "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
4107                            "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
4108                            "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
4109                            "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
4110                            "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
4111                            "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
4112                            "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
4113                            "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
4114                            "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
4115                            "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]",
4116                            "[$FALSE$]",
4117                            "[$TRUE$]"
4118                    };
4119    
4120                    DB db = DBFactoryUtil.getDB();
4121    
4122                    Object[] customSqlValues = new Object[] {
4123                            getClassNameId(Group.class),
4124                            getClassNameId(Layout.class),
4125                            getClassNameId(Organization.class),
4126                            getClassNameId(Role.class),
4127                            getClassNameId(User.class),
4128                            getClassNameId(UserGroup.class),
4129                            getClassNameId(BlogsEntry.class),
4130                            getClassNameId(BookmarksEntry.class),
4131                            getClassNameId(CalEvent.class),
4132                            getClassNameId(DLFileEntry.class),
4133                            getClassNameId(MBMessage.class),
4134                            getClassNameId(MBThread.class),
4135                            getClassNameId(WikiPage.class),
4136                            ResourceConstants.SCOPE_COMPANY,
4137                            ResourceConstants.SCOPE_GROUP,
4138                            ResourceConstants.SCOPE_GROUP_TEMPLATE,
4139                            ResourceConstants.SCOPE_INDIVIDUAL,
4140                            SocialRelationConstants.TYPE_BI_COWORKER,
4141                            SocialRelationConstants.TYPE_BI_FRIEND,
4142                            SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
4143                            SocialRelationConstants.TYPE_BI_SIBLING,
4144                            SocialRelationConstants.TYPE_BI_SPOUSE,
4145                            SocialRelationConstants.TYPE_UNI_CHILD,
4146                            SocialRelationConstants.TYPE_UNI_ENEMY,
4147                            SocialRelationConstants.TYPE_UNI_FOLLOWER,
4148                            SocialRelationConstants.TYPE_UNI_PARENT,
4149                            SocialRelationConstants.TYPE_UNI_SUBORDINATE,
4150                            SocialRelationConstants.TYPE_UNI_SUPERVISOR,
4151                            db.getTemplateFalse(),
4152                            db.getTemplateTrue()
4153                    };
4154    
4155                    _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
4156            }
4157    
4158            public boolean isAllowAddPortletDefaultResource(
4159                            HttpServletRequest request, Portlet portlet)
4160                    throws PortalException, SystemException {
4161    
4162                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4163                            WebKeys.THEME_DISPLAY);
4164    
4165                    Layout layout = themeDisplay.getLayout();
4166                    LayoutTypePortlet layoutTypePortlet =
4167                            themeDisplay.getLayoutTypePortlet();
4168    
4169                    String portletId = portlet.getPortletId();
4170    
4171                    Boolean renderPortletResource = (Boolean)request.getAttribute(
4172                            WebKeys.RENDER_PORTLET_RESOURCE);
4173    
4174                    if (renderPortletResource != null) {
4175                            boolean runtimePortlet = renderPortletResource.booleanValue();
4176    
4177                            if (runtimePortlet) {
4178                                    return true;
4179                            }
4180                    }
4181    
4182                    if (layout.isTypePanel()) {
4183                            return true;
4184                    }
4185    
4186                    if (layout.isTypeControlPanel() &&
4187                            isControlPanelPortlet(portletId, themeDisplay)) {
4188    
4189                            return true;
4190                    }
4191    
4192                    if (layout.isTypePortlet()) {
4193                            String checkPortletId = portletId;
4194    
4195                            String outerPortletId = getOuterPortletId(request);
4196    
4197                            if (outerPortletId != null) {
4198                                    checkPortletId = outerPortletId;
4199                            }
4200    
4201                            if (layoutTypePortlet.hasPortletId(checkPortletId)) {
4202                                    return true;
4203                            }
4204                    }
4205    
4206                    if (themeDisplay.isSignedIn() &&
4207                            (portletId.equals(PortletKeys.LAYOUT_CONFIGURATION) ||
4208                             portletId.equals(PortletKeys.LAYOUTS_ADMIN))) {
4209    
4210                            PermissionChecker permissionChecker =
4211                                    themeDisplay.getPermissionChecker();
4212    
4213                            Group group = layout.getGroup();
4214    
4215                            if (group.isSite()) {
4216                                    if (LayoutPermissionUtil.contains(
4217                                                    permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
4218                                            LayoutPermissionUtil.contains(
4219                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
4220    
4221                                            return true;
4222                                    }
4223                            }
4224    
4225                            if (group.isCompany()) {
4226                                    if (permissionChecker.isCompanyAdmin()) {
4227                                            return true;
4228                                    }
4229                            }
4230                            else if (group.isLayoutPrototype()) {
4231                                    long layoutPrototypeId = group.getClassPK();
4232    
4233                                    if (LayoutPrototypePermissionUtil.contains(
4234                                                    permissionChecker, layoutPrototypeId,
4235                                                    ActionKeys.UPDATE)) {
4236    
4237                                            return true;
4238                                    }
4239                            }
4240                            else if (group.isLayoutSetPrototype()) {
4241                                    long layoutSetPrototypeId = group.getClassPK();
4242    
4243                                    if (LayoutSetPrototypePermissionUtil.contains(
4244                                                    permissionChecker, layoutSetPrototypeId,
4245                                                    ActionKeys.UPDATE)) {
4246    
4247                                            return true;
4248                                    }
4249                            }
4250                            else if (group.isOrganization()) {
4251                                    long organizationId = group.getOrganizationId();
4252    
4253                                    if (OrganizationPermissionUtil.contains(
4254                                                    permissionChecker, organizationId, ActionKeys.UPDATE)) {
4255    
4256                                            return true;
4257                                    }
4258                            }
4259                            else if (group.isUserGroup()) {
4260                                    long scopeGroupId = themeDisplay.getScopeGroupId();
4261    
4262                                    if (GroupPermissionUtil.contains(
4263                                                    permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
4264    
4265                                            return true;
4266                                    }
4267                            }
4268                            else if (group.isUser()) {
4269                                    return true;
4270                            }
4271                    }
4272    
4273                    if (!portlet.isAddDefaultResource()) {
4274                            return false;
4275                    }
4276    
4277                    if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
4278                            return true;
4279                    }
4280    
4281                    if (_portletAddDefaultResourceCheckWhitelist.contains(portletId)) {
4282                            return true;
4283                    }
4284    
4285                    String strutsAction = ParamUtil.getString(request, "struts_action");
4286    
4287                    if (_portletAddDefaultResourceCheckWhitelistActions.contains(
4288                                    strutsAction)) {
4289    
4290                            return true;
4291                    }
4292    
4293                    String requestPortletAuthenticationToken = ParamUtil.getString(
4294                            request, "p_p_auth");
4295    
4296                    if (Validator.isNull(requestPortletAuthenticationToken)) {
4297                            HttpServletRequest originalRequest = getOriginalServletRequest(
4298                                    request);
4299    
4300                            requestPortletAuthenticationToken = ParamUtil.getString(
4301                                    originalRequest, "p_p_auth");
4302                    }
4303    
4304                    if (Validator.isNotNull(requestPortletAuthenticationToken)) {
4305                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
4306                                    request, layout.getPlid(), portletId);
4307    
4308                            if (requestPortletAuthenticationToken.equals(
4309                                            actualPortletAuthenticationToken)) {
4310    
4311                                    return true;
4312                            }
4313                    }
4314    
4315                    return false;
4316            }
4317    
4318            /**
4319             * @deprecated As of 6.1, renamed to {@link #isGroupAdmin(User, long)}
4320             */
4321            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
4322                    return isGroupAdmin(user, groupId);
4323            }
4324    
4325            /**
4326             * @deprecated As of 6.1, renamed to {@link #isGroupOwner(User, long)}
4327             */
4328            public boolean isCommunityOwner(User user, long groupId) throws Exception {
4329                    return isGroupOwner(user, groupId);
4330            }
4331    
4332            public boolean isCompanyAdmin(User user) throws Exception {
4333                    PermissionChecker permissionChecker =
4334                            PermissionCheckerFactoryUtil.create(user, true);
4335    
4336                    return permissionChecker.isCompanyAdmin();
4337            }
4338    
4339            public boolean isCompanyControlPanelPortlet(
4340                            String portletId, String category, ThemeDisplay themeDisplay)
4341                    throws PortalException, SystemException {
4342    
4343                    PermissionChecker permissionChecker =
4344                            themeDisplay.getPermissionChecker();
4345    
4346                    if (permissionChecker.isCompanyAdmin()) {
4347                            return true;
4348                    }
4349    
4350                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4351                            themeDisplay.getCompanyId());
4352    
4353                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4354    
4355                    return isControlPanelPortlet(portletId, category, themeDisplay);
4356            }
4357    
4358            public boolean isCompanyControlPanelPortlet(
4359                            String portletId, ThemeDisplay themeDisplay)
4360                    throws PortalException, SystemException {
4361    
4362                    PermissionChecker permissionChecker =
4363                            themeDisplay.getPermissionChecker();
4364    
4365                    if (permissionChecker.isCompanyAdmin()) {
4366                            return true;
4367                    }
4368    
4369                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4370                            themeDisplay.getCompanyId());
4371    
4372                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4373    
4374                    return isControlPanelPortlet(portletId, themeDisplay);
4375            }
4376    
4377            public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
4378                    throws PortalException, SystemException {
4379    
4380                    PermissionChecker permissionChecker =
4381                            themeDisplay.getPermissionChecker();
4382    
4383                    if (permissionChecker.isCompanyAdmin()) {
4384                            return true;
4385                    }
4386    
4387                    long scopeGroupId = themeDisplay.getScopeGroupId();
4388    
4389                    try {
4390                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4391                                    themeDisplay.getCompanyId());
4392    
4393                            themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4394    
4395                            List<Portlet> controlPanelPortlets = getControlPanelPortlets(
4396                                    PortletCategoryKeys.CONTENT, themeDisplay);
4397    
4398                            if (!controlPanelPortlets.isEmpty()) {
4399                                    return true;
4400                            }
4401                            else {
4402                                    return false;
4403                            }
4404                    }
4405                    finally {
4406                            themeDisplay.setScopeGroupId(scopeGroupId);
4407                    }
4408            }
4409    
4410            public boolean isControlPanelPortlet(
4411                            String portletId, String category, ThemeDisplay themeDisplay)
4412                    throws SystemException {
4413    
4414                    List<Portlet> portlets = getControlPanelPortlets(
4415                            category, themeDisplay);
4416    
4417                    for (Portlet portlet : portlets) {
4418                            if (portlet.getPortletId().equals(portletId)) {
4419                                    return true;
4420                            }
4421                    }
4422    
4423                    return false;
4424            }
4425    
4426            public boolean isControlPanelPortlet(
4427                            String portletId, ThemeDisplay themeDisplay)
4428                    throws SystemException {
4429    
4430                    for (String category : PortletCategoryKeys.ALL) {
4431                            if (isControlPanelPortlet(portletId, category, themeDisplay)) {
4432                                    return true;
4433                            }
4434                    }
4435    
4436                    return false;
4437            }
4438    
4439            public boolean isGroupAdmin(User user, long groupId) throws Exception {
4440                    PermissionChecker permissionChecker =
4441                            PermissionCheckerFactoryUtil.create(user, true);
4442    
4443                    return permissionChecker.isGroupAdmin(groupId);
4444            }
4445    
4446            public boolean isGroupOwner(User user, long groupId) throws Exception {
4447                    PermissionChecker permissionChecker =
4448                            PermissionCheckerFactoryUtil.create(user, true);
4449    
4450                    return permissionChecker.isGroupOwner(groupId);
4451            }
4452    
4453            public boolean isLayoutDescendant(Layout layout, long layoutId)
4454                    throws PortalException, SystemException {
4455    
4456                    if (layout.getLayoutId() == layoutId) {
4457                            return true;
4458                    }
4459                    else {
4460                            for (Layout childLayout : layout.getChildren()) {
4461                                    if (isLayoutDescendant(childLayout, layoutId)) {
4462                                            return true;
4463                                    }
4464                            }
4465    
4466                            return false;
4467                    }
4468            }
4469    
4470            public boolean isLayoutFirstPageable(Layout layout) {
4471                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4472    
4473                    return layoutSettings.isFirstPageable();
4474            }
4475    
4476            public boolean isLayoutFirstPageable(String type) {
4477                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4478    
4479                    return layoutSettings.isFirstPageable();
4480            }
4481    
4482            public boolean isLayoutFriendliable(Layout layout) {
4483                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4484    
4485                    return layoutSettings.isURLFriendliable();
4486            }
4487    
4488            public boolean isLayoutFriendliable(String type) {
4489                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4490    
4491                    return layoutSettings.isURLFriendliable();
4492            }
4493    
4494            public boolean isLayoutParentable(Layout layout) {
4495                    return isLayoutParentable(layout.getType());
4496            }
4497    
4498            public boolean isLayoutParentable(String type) {
4499                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4500    
4501                    return layoutSettings.isParentable();
4502            }
4503    
4504            public boolean isLayoutSitemapable(Layout layout) {
4505                    if (layout.isPrivateLayout()) {
4506                            return false;
4507                    }
4508    
4509                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4510    
4511                    return layoutSettings.isSitemapable();
4512            }
4513    
4514            public boolean isMethodGet(PortletRequest portletRequest) {
4515                    HttpServletRequest request = getHttpServletRequest(portletRequest);
4516    
4517                    String method = GetterUtil.getString(request.getMethod());
4518    
4519                    if (method.equalsIgnoreCase(HttpMethods.GET)) {
4520                            return true;
4521                    }
4522                    else {
4523                            return false;
4524                    }
4525            }
4526    
4527            public boolean isMethodPost(PortletRequest portletRequest) {
4528                    HttpServletRequest request = getHttpServletRequest(portletRequest);
4529    
4530                    String method = GetterUtil.getString(request.getMethod());
4531    
4532                    if (method.equalsIgnoreCase(HttpMethods.POST)) {
4533                            return true;
4534                    }
4535                    else {
4536                            return false;
4537                    }
4538            }
4539    
4540            public boolean isMultipartRequest(HttpServletRequest request) {
4541                    String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
4542    
4543                    if ((contentType != null) &&
4544                            contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
4545    
4546                            return true;
4547                    }
4548                    else {
4549                            return false;
4550                    }
4551            }
4552    
4553            public boolean isOmniadmin(long userId) {
4554                    return OmniadminUtil.isOmniadmin(userId);
4555            }
4556    
4557            public boolean isReservedParameter(String name) {
4558                    return _reservedParams.contains(name);
4559            }
4560    
4561            public boolean isSecure(HttpServletRequest request) {
4562                    HttpSession session = request.getSession();
4563    
4564                    Boolean httpsInitial = (Boolean)session.getAttribute(
4565                            WebKeys.HTTPS_INITIAL);
4566    
4567                    boolean secure = false;
4568    
4569                    if ((PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS) &&
4570                            (!PropsValues.SESSION_ENABLE_PHISHING_PROTECTION) &&
4571                            (httpsInitial != null) && (!httpsInitial.booleanValue())) {
4572    
4573                            secure = false;
4574                    }
4575                    else {
4576                            secure = request.isSecure();
4577                    }
4578    
4579                    return secure;
4580            }
4581    
4582            public boolean isSystemGroup(String groupName) {
4583                    if (groupName == null) {
4584                            return false;
4585                    }
4586    
4587                    groupName = groupName.trim();
4588    
4589                    int pos = Arrays.binarySearch(
4590                            _sortedSystemGroups, groupName, new StringComparator());
4591    
4592                    if (pos >= 0) {
4593                            return true;
4594                    }
4595                    else {
4596                            return false;
4597                    }
4598            }
4599    
4600            public boolean isSystemRole(String roleName) {
4601                    if (roleName == null) {
4602                            return false;
4603                    }
4604    
4605                    roleName = roleName.trim();
4606    
4607                    int pos = Arrays.binarySearch(
4608                            _sortedSystemRoles, roleName, new StringComparator());
4609    
4610                    if (pos >= 0) {
4611                            return true;
4612                    }
4613                    else {
4614                            pos = Arrays.binarySearch(
4615                                    _sortedSystemSiteRoles, roleName, new StringComparator());
4616    
4617                            if (pos >= 0) {
4618                                    return true;
4619                            }
4620                            else {
4621                                    pos = Arrays.binarySearch(
4622                                            _sortedSystemOrganizationRoles, roleName,
4623                                            new StringComparator());
4624    
4625                                    if (pos >= 0) {
4626                                            return true;
4627                                    }
4628                            }
4629                    }
4630    
4631                    return false;
4632            }
4633    
4634            public boolean isUpdateAvailable() throws SystemException {
4635                    return PluginPackageUtil.isUpdateAvailable();
4636            }
4637    
4638            public boolean isValidResourceId(String resourceId) {
4639                    if (Validator.isNull(resourceId)) {
4640                            return true;
4641                    }
4642    
4643                    Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
4644    
4645                    if (matcher.matches()) {
4646                            return false;
4647                    }
4648    
4649                    return true;
4650            }
4651    
4652            public void removePortalPortEventListener(
4653                    PortalPortEventListener portalPortEventListener) {
4654    
4655                    _portalPortEventListeners.remove(portalPortEventListener);
4656            }
4657    
4658            public String renderPage(
4659                            ServletContext servletContext, HttpServletRequest request,
4660                            HttpServletResponse response, String path)
4661                    throws IOException, ServletException {
4662    
4663                    RequestDispatcher requestDispatcher =
4664                            servletContext.getRequestDispatcher(path);
4665    
4666                    StringServletResponse stringResponse = new StringServletResponse(
4667                            response);
4668    
4669                    requestDispatcher.include(request, stringResponse);
4670    
4671                    return stringResponse.getString();
4672            }
4673    
4674            public String renderPortlet(
4675                            ServletContext servletContext, HttpServletRequest request,
4676                            HttpServletResponse response, Portlet portlet, String queryString,
4677                            boolean writeOutput)
4678                    throws IOException, ServletException {
4679    
4680                    return renderPortlet(
4681                            servletContext, request, response, portlet, queryString, null, null,
4682                            null, writeOutput);
4683            }
4684    
4685            public String renderPortlet(
4686                            ServletContext servletContext, HttpServletRequest request,
4687                            HttpServletResponse response, Portlet portlet, String queryString,
4688                            String columnId, Integer columnPos, Integer columnCount,
4689                            boolean writeOutput)
4690                    throws IOException, ServletException {
4691    
4692                    return renderPortlet(
4693                            servletContext, request, response, portlet, queryString, columnId,
4694                            columnPos, columnCount, null, writeOutput);
4695            }
4696    
4697            public String renderPortlet(
4698                            ServletContext servletContext, HttpServletRequest request,
4699                            HttpServletResponse response, Portlet portlet, String queryString,
4700                            String columnId, Integer columnPos, Integer columnCount,
4701                            String path, boolean writeOutput)
4702                    throws IOException, ServletException {
4703    
4704                    queryString = GetterUtil.getString(queryString);
4705                    columnId = GetterUtil.getString(columnId);
4706    
4707                    if (columnPos == null) {
4708                            columnPos = Integer.valueOf(0);
4709                    }
4710    
4711                    if (columnCount == null) {
4712                            columnCount = Integer.valueOf(0);
4713                    }
4714    
4715                    request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
4716                    request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
4717                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
4718                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
4719                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
4720    
4721                    if (path == null) {
4722                            path = "/html/portal/render_portlet.jsp";
4723                    }
4724    
4725                    RequestDispatcher requestDispatcher =
4726                            servletContext.getRequestDispatcher(path);
4727    
4728                    UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
4729    
4730                    PipingServletResponse pipingServletResponse = new PipingServletResponse(
4731                            response, unsyncStringWriter);
4732    
4733                    requestDispatcher.include(request, pipingServletResponse);
4734    
4735                    boolean showPortlet = true;
4736    
4737                    Boolean portletConfiguratorVisibility = (Boolean)request.getAttribute(
4738                            WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
4739    
4740                    if (portletConfiguratorVisibility != null) {
4741                            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4742                                    WebKeys.THEME_DISPLAY);
4743    
4744                            try {
4745                                    Layout layout = themeDisplay.getLayout();
4746    
4747                                    if (!layout.isTypeControlPanel() &&
4748                                            !PortletPermissionUtil.contains(
4749                                                    themeDisplay.getPermissionChecker(),
4750                                                    themeDisplay.getPlid(), portlet.getPortletId(),
4751                                                    ActionKeys.ADD_TO_PAGE) &&
4752                                            !PortletPermissionUtil.contains(
4753                                                    themeDisplay.getPermissionChecker(),
4754                                                    themeDisplay.getPlid(), portlet.getPortletId(),
4755                                                    ActionKeys.CONFIGURATION)) {
4756    
4757                                            showPortlet = false;
4758                                    }
4759                            }
4760                            catch (Exception e) {
4761                                    throw new ServletException(e);
4762                            }
4763    
4764                            request.removeAttribute(WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
4765                    }
4766    
4767                    if (showPortlet) {
4768                            if (writeOutput) {
4769                                    response.setContentType(ContentTypes.TEXT_HTML_UTF8);
4770    
4771                                    StringBundler sb = unsyncStringWriter.getStringBundler();
4772    
4773                                    sb.writeTo(response.getWriter());
4774    
4775                                    return StringPool.BLANK;
4776                            }
4777                            else {
4778                                    return unsyncStringWriter.toString();
4779                            }
4780                    }
4781                    else {
4782                            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
4783    
4784                            return StringPool.BLANK;
4785                    }
4786            }
4787    
4788            public void resetCDNHosts() {
4789                    _cdnHostHttpMap.clear();
4790                    _cdnHostHttpsMap.clear();
4791    
4792                    if (!ClusterInvokeThreadLocal.isEnabled()) {
4793                            return;
4794                    }
4795    
4796                    ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
4797                            _resetCDNHostsMethodHandler, true);
4798    
4799                    try {
4800                            ClusterExecutorUtil.execute(clusterRequest);
4801                    }
4802                    catch (Exception e) {
4803                            _log.error("Unable to clear cluster wide CDN hosts", e);
4804                    }
4805            }
4806    
4807            public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
4808                    _portletAddDefaultResourceCheckWhitelist = SetUtil.fromArray(
4809                            PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST);
4810    
4811                    _portletAddDefaultResourceCheckWhitelist = Collections.unmodifiableSet(
4812                            _portletAddDefaultResourceCheckWhitelist);
4813    
4814                    return _portletAddDefaultResourceCheckWhitelist;
4815            }
4816    
4817            public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
4818                    _portletAddDefaultResourceCheckWhitelistActions = SetUtil.fromArray(
4819                            PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS);
4820    
4821                    _portletAddDefaultResourceCheckWhitelistActions =
4822                            Collections.unmodifiableSet(
4823                                    _portletAddDefaultResourceCheckWhitelistActions);
4824    
4825                    return _portletAddDefaultResourceCheckWhitelistActions;
4826            }
4827    
4828            public void sendError(
4829                            Exception e, ActionRequest actionRequest,
4830                            ActionResponse actionResponse)
4831                    throws IOException {
4832    
4833                    sendError(0, e, actionRequest, actionResponse);
4834            }
4835    
4836            public void sendError(
4837                            Exception e, HttpServletRequest request,
4838                            HttpServletResponse response)
4839                    throws IOException, ServletException {
4840    
4841                    sendError(0, e, request, response);
4842            }
4843    
4844            public void sendError(
4845                            int status, Exception e, ActionRequest actionRequest,
4846                            ActionResponse actionResponse)
4847                    throws IOException {
4848    
4849                    StringBundler sb = new StringBundler(7);
4850    
4851                    sb.append(_pathMain);
4852                    sb.append("/portal/status?status=");
4853                    sb.append(status);
4854                    sb.append("&exception=");
4855                    sb.append(e.getClass().getName());
4856                    sb.append("&previousURL=");
4857                    sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
4858    
4859                    actionResponse.sendRedirect(sb.toString());
4860            }
4861    
4862            public void sendError(
4863                            int status, Exception e, HttpServletRequest request,
4864                            HttpServletResponse response)
4865                    throws IOException, ServletException {
4866    
4867                    if (_log.isInfoEnabled()) {
4868                            String currentURL = (String)request.getAttribute(
4869                                    WebKeys.CURRENT_URL);
4870    
4871                            _log.info(
4872                                    "Current URL " + currentURL + " generates exception: " +
4873                                            e.getMessage());
4874                    }
4875    
4876                    if (e instanceof NoSuchImageException) {
4877                            if (_logWebServerServlet.isWarnEnabled()) {
4878                                    _logWebServerServlet.warn(e, e);
4879                            }
4880                    }
4881                    else if ((e instanceof PortalException) && _log.isInfoEnabled()) {
4882                            if ((e instanceof NoSuchLayoutException) ||
4883                                    (e instanceof PrincipalException)) {
4884    
4885                                    String msg = e.getMessage();
4886    
4887                                    if (Validator.isNotNull(msg)) {
4888                                            _log.info(msg);
4889                                    }
4890                            }
4891                            else {
4892                                    _log.info(e, e);
4893                            }
4894                    }
4895                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
4896                            _log.warn(e, e);
4897                    }
4898    
4899                    if (response.isCommitted()) {
4900                            return;
4901                    }
4902    
4903                    if (status == 0) {
4904                            if (e instanceof PrincipalException) {
4905                                    status = HttpServletResponse.SC_FORBIDDEN;
4906                            }
4907                            else {
4908                                    String name = e.getClass().getName();
4909    
4910                                    name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
4911    
4912                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
4913                                            status = HttpServletResponse.SC_NOT_FOUND;
4914                                    }
4915                            }
4916    
4917                            if (status == 0) {
4918    
4919                                    // LPS-5352
4920    
4921                                    if (PropsValues.TCK_URL) {
4922                                            status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
4923                                    }
4924                                    else {
4925                                            status = HttpServletResponse.SC_BAD_REQUEST;
4926                                    }
4927                            }
4928                    }
4929    
4930                    HttpSession session = request.getSession();
4931    
4932                    ServletContext servletContext = session.getServletContext();
4933    
4934                    String redirect = PATH_MAIN + "/portal/status";
4935    
4936                    if ((e instanceof NoSuchLayoutException) &&
4937                            Validator.isNotNull(
4938                                    PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
4939    
4940                            response.setStatus(status);
4941    
4942                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
4943    
4944                            RequestDispatcher requestDispatcher =
4945                                    servletContext.getRequestDispatcher(redirect);
4946    
4947                            if (requestDispatcher != null) {
4948                                    requestDispatcher.forward(request, response);
4949                            }
4950                    }
4951                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
4952                            response.setStatus(status);
4953    
4954                            SessionErrors.add(request, e.getClass().getName(), e);
4955    
4956                            RequestDispatcher requestDispatcher =
4957                                    servletContext.getRequestDispatcher(redirect);
4958    
4959                            if (requestDispatcher != null) {
4960                                    requestDispatcher.forward(request, response);
4961                            }
4962                    }
4963                    else {
4964                            if (e != null) {
4965                                    response.sendError(status, e.getMessage());
4966                            }
4967                            else {
4968                                    response.sendError(status);
4969                            }
4970                    }
4971            }
4972    
4973            public void setPageDescription(
4974                    String description, HttpServletRequest request) {
4975    
4976                    request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
4977            }
4978    
4979            public void setPageKeywords(String keywords, HttpServletRequest request) {
4980                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
4981    
4982                    addPageKeywords(keywords, request);
4983            }
4984    
4985            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
4986                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
4987            }
4988    
4989            public void setPageTitle(String title, HttpServletRequest request) {
4990                    request.setAttribute(WebKeys.PAGE_TITLE, title);
4991            }
4992    
4993            public void setPortalPort(HttpServletRequest request) {
4994                    if (request.isSecure()) {
4995                            if (_securePortalPort.get() == -1) {
4996                                    int securePortalPort = request.getServerPort();
4997    
4998                                    _securePortalPort.compareAndSet(-1, securePortalPort);
4999                            }
5000                    }
5001                    else {
5002                            if (_portalPort.get() == -1) {
5003                                    int portalPort = request.getServerPort();
5004    
5005                                    if (_portalPort.compareAndSet(-1, portalPort)) {
5006                                            notifyPortalPortEventListeners(portalPort);
5007                                    }
5008                            }
5009                    }
5010            }
5011    
5012            public void storePreferences(PortletPreferences portletPreferences)
5013                    throws IOException, ValidatorException {
5014    
5015                    PortletPreferencesWrapper portletPreferencesWrapper =
5016                            (PortletPreferencesWrapper)portletPreferences;
5017    
5018                    PortletPreferencesImpl portletPreferencesImpl =
5019                            portletPreferencesWrapper.getPortletPreferencesImpl();
5020    
5021                    portletPreferencesImpl.store();
5022            }
5023    
5024            public String[] stripURLAnchor(String url, String separator) {
5025                    String anchor = StringPool.BLANK;
5026    
5027                    int pos = url.indexOf(separator);
5028    
5029                    if (pos != -1) {
5030                            anchor = url.substring(pos);
5031                            url = url.substring(0, pos);
5032                    }
5033    
5034                    return new String[] {url, anchor};
5035            }
5036    
5037            public String transformCustomSQL(String sql) {
5038                    if ((_customSqlKeys == null) || (_customSqlValues == null)) {
5039                            initCustomSQL();
5040                    }
5041    
5042                    return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
5043            }
5044    
5045            public PortletMode updatePortletMode(
5046                    String portletId, User user, Layout layout, PortletMode portletMode,
5047                    HttpServletRequest request) {
5048    
5049                    LayoutTypePortlet layoutType =
5050                            (LayoutTypePortlet)layout.getLayoutType();
5051    
5052                    if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
5053                            if (layoutType.hasModeAboutPortletId(portletId)) {
5054                                    return LiferayPortletMode.ABOUT;
5055                            }
5056                            else if (layoutType.hasModeConfigPortletId(portletId)) {
5057                                    return LiferayPortletMode.CONFIG;
5058                            }
5059                            else if (layoutType.hasModeEditPortletId(portletId)) {
5060                                    return PortletMode.EDIT;
5061                            }
5062                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
5063                                    return LiferayPortletMode.EDIT_DEFAULTS;
5064                            }
5065                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
5066                                    return LiferayPortletMode.EDIT_GUEST;
5067                            }
5068                            else if (layoutType.hasModeHelpPortletId(portletId)) {
5069                                    return PortletMode.HELP;
5070                            }
5071                            else if (layoutType.hasModePreviewPortletId(portletId)) {
5072                                    return LiferayPortletMode.PREVIEW;
5073                            }
5074                            else if (layoutType.hasModePrintPortletId(portletId)) {
5075                                    return LiferayPortletMode.PRINT;
5076                            }
5077                            else {
5078                                    return PortletMode.VIEW;
5079                            }
5080                    }
5081                    else {
5082                            boolean updateLayout = false;
5083    
5084                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
5085                                    !layoutType.hasModeAboutPortletId(portletId)) {
5086    
5087                                    layoutType.addModeAboutPortletId(portletId);
5088    
5089                                    updateLayout = true;
5090                            }
5091                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
5092                                             !layoutType.hasModeConfigPortletId(portletId)) {
5093    
5094                                    layoutType.addModeConfigPortletId(portletId);
5095    
5096                                    updateLayout = true;
5097                            }
5098                            else if (portletMode.equals(PortletMode.EDIT) &&
5099                                             !layoutType.hasModeEditPortletId(portletId)) {
5100    
5101                                    layoutType.addModeEditPortletId(portletId);
5102    
5103                                    updateLayout = true;
5104                            }
5105                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
5106                                             !layoutType.hasModeEditDefaultsPortletId(portletId)) {
5107    
5108                                    layoutType.addModeEditDefaultsPortletId(portletId);
5109    
5110                                    updateLayout = true;
5111                            }
5112                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
5113                                             !layoutType.hasModeEditGuestPortletId(portletId)) {
5114    
5115                                    layoutType.addModeEditGuestPortletId(portletId);
5116    
5117                                    updateLayout = true;
5118                            }
5119                            else if (portletMode.equals(PortletMode.HELP) &&
5120                                             !layoutType.hasModeHelpPortletId(portletId)) {
5121    
5122                                    layoutType.addModeHelpPortletId(portletId);
5123    
5124                                    updateLayout = true;
5125                            }
5126                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
5127                                             !layoutType.hasModePreviewPortletId(portletId)) {
5128    
5129                                    layoutType.addModePreviewPortletId(portletId);
5130    
5131                                    updateLayout = true;
5132                            }
5133                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
5134                                             !layoutType.hasModePrintPortletId(portletId)) {
5135    
5136                                    layoutType.addModePrintPortletId(portletId);
5137    
5138                                    updateLayout = true;
5139                            }
5140                            else if (portletMode.equals(PortletMode.VIEW) &&
5141                                             !layoutType.hasModeViewPortletId(portletId)) {
5142    
5143                                    layoutType.removeModesPortletId(portletId);
5144    
5145                                    updateLayout = true;
5146                            }
5147    
5148                            if (updateLayout) {
5149                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
5150    
5151                                    if (layoutClone != null) {
5152                                            layoutClone.update(
5153                                                    request, layout.getPlid(), layout.getTypeSettings());
5154                                    }
5155                            }
5156    
5157                            return portletMode;
5158                    }
5159            }
5160    
5161            public String updateRedirect(
5162                    String redirect, String oldPath, String newPath) {
5163    
5164                    if (Validator.isNotNull(redirect) && (oldPath != null) &&
5165                            !oldPath.equals(newPath)) {
5166    
5167                            redirect = StringUtil.replace(redirect, oldPath, newPath);
5168                            redirect = StringUtil.replace(
5169                                    redirect, HttpUtil.encodeURL(oldPath),
5170                                    HttpUtil.encodeURL(newPath));
5171                    }
5172    
5173                    return redirect;
5174            }
5175    
5176            public WindowState updateWindowState(
5177                    String portletId, User user, Layout layout, WindowState windowState,
5178                    HttpServletRequest request) {
5179    
5180                    LayoutTypePortlet layoutType =
5181                            (LayoutTypePortlet)layout.getLayoutType();
5182    
5183                    if ((windowState == null) ||
5184                            (Validator.isNull(windowState.toString()))) {
5185    
5186                            if (layoutType.hasStateMaxPortletId(portletId)) {
5187                                    windowState = WindowState.MAXIMIZED;
5188                            }
5189                            else if (layoutType.hasStateMinPortletId(portletId)) {
5190                                    windowState = WindowState.MINIMIZED;
5191                            }
5192                            else {
5193                                    windowState = WindowState.NORMAL;
5194                            }
5195                    }
5196                    else {
5197                            boolean updateLayout = false;
5198    
5199                            if (windowState.equals(WindowState.MAXIMIZED) &&
5200                                    !layoutType.hasStateMaxPortletId(portletId)) {
5201    
5202                                    layoutType.addStateMaxPortletId(portletId);
5203    
5204                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
5205                                            updateLayout = true;
5206                                    }
5207                            }
5208                            else if (windowState.equals(WindowState.MINIMIZED) &&
5209                                             !layoutType.hasStateMinPortletId(portletId)) {
5210    
5211                                    layoutType.addStateMinPortletId(portletId);
5212    
5213                                    updateLayout = true;
5214                            }
5215                            else if (windowState.equals(WindowState.NORMAL) &&
5216                                             !layoutType.hasStateNormalPortletId(portletId)) {
5217    
5218                                    layoutType.removeStatesPortletId(portletId);
5219    
5220                                    updateLayout = true;
5221                            }
5222    
5223                            if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
5224                                    portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
5225    
5226                                    updateLayout = false;
5227                            }
5228    
5229                            if (updateLayout) {
5230                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
5231    
5232                                    if (layoutClone != null) {
5233                                            layoutClone.update(
5234                                                    request, layout.getPlid(), layout.getTypeSettings());
5235                                    }
5236                            }
5237                    }
5238    
5239                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5240                            WebKeys.THEME_DISPLAY);
5241    
5242                    themeDisplay.setStateExclusive(
5243                            windowState.equals(LiferayWindowState.EXCLUSIVE));
5244                    themeDisplay.setStateMaximized(
5245                            windowState.equals(WindowState.MAXIMIZED));
5246                    themeDisplay.setStatePopUp(
5247                            windowState.equals(LiferayWindowState.POP_UP));
5248    
5249                    if (themeDisplay.isStateMaximized() &&
5250                            themeDisplay.isShowAddContentIcon()) {
5251    
5252                            themeDisplay.setShowAddContentIcon(false);
5253                    }
5254                    else if (!themeDisplay.isStateMaximized() &&
5255                                     !themeDisplay.isShowAddContentIcon() &&
5256                                     themeDisplay.isShowAddContentIconPermission()) {
5257    
5258                            themeDisplay.setShowAddContentIcon(true);
5259                    }
5260    
5261                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
5262    
5263                    return windowState;
5264            }
5265    
5266            protected void addDefaultResource(
5267                            long companyId, Layout layout, Portlet portlet,
5268                            boolean portletActions)
5269                    throws PortalException, SystemException {
5270    
5271                    String rootPortletId = portlet.getRootPortletId();
5272    
5273                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
5274                            layout.getPlid(), portlet.getPortletId());
5275    
5276                    String name = null;
5277                    String primaryKey = null;
5278    
5279                    if (portletActions) {
5280                            name = rootPortletId;
5281                            primaryKey = portletPrimaryKey;
5282                    }
5283                    else {
5284                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
5285                            primaryKey = String.valueOf(
5286                                    getScopeGroupId(layout, portlet.getPortletId()));
5287                    }
5288    
5289                    if (Validator.isNull(name)) {
5290                            return;
5291                    }
5292    
5293                    try {
5294                            if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
5295                                    int count =
5296                                            ResourcePermissionLocalServiceUtil.
5297                                                    getResourcePermissionsCount(
5298                                                            companyId, name,
5299                                                            ResourceConstants.SCOPE_INDIVIDUAL, primaryKey);
5300    
5301                                    if (count == 0) {
5302                                            throw new NoSuchResourceException();
5303                                    }
5304                            }
5305                            else if (!portlet.isUndeployedPortlet()) {
5306                                    ResourceLocalServiceUtil.getResource(
5307                                            companyId, name,
5308                                            ResourceConstants.SCOPE_INDIVIDUAL, primaryKey);
5309                            }
5310                    }
5311                    catch (NoSuchResourceException nsre) {
5312                            ResourceLocalServiceUtil.addResources(
5313                                    companyId, layout.getGroupId(), 0, name, primaryKey,
5314                                    portletActions, true, true);
5315                    }
5316            }
5317    
5318            protected void addDefaultResource(
5319                            ThemeDisplay themeDisplay, Layout layout, Portlet portlet,
5320                            boolean portletActions)
5321                    throws PortalException, SystemException {
5322    
5323                    addDefaultResource(
5324                            themeDisplay.getCompanyId(), layout, portlet, portletActions);
5325            }
5326    
5327            protected String buildI18NPath(Locale locale) {
5328                    if (Validator.isNull(locale.toString())) {
5329                            return null;
5330                    }
5331    
5332                    String i18nPath = StringPool.SLASH.concat(locale.toString());
5333    
5334                    if (!LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
5335                            i18nPath = StringPool.SLASH.concat(locale.getLanguage());
5336                    }
5337                    else {
5338                            Locale priorityLocale = LanguageUtil.getLocale(
5339                                    locale.getLanguage());
5340    
5341                            if (locale.equals(priorityLocale)) {
5342                                    i18nPath = StringPool.SLASH.concat(locale.getLanguage());
5343                            }
5344                    }
5345    
5346                    return i18nPath;
5347            }
5348    
5349            protected long doGetPlidFromPortletId(
5350                            long groupId, boolean privateLayout, String portletId)
5351                    throws PortalException, SystemException {
5352    
5353                    long scopeGroupId = groupId;
5354    
5355                    try {
5356                            Group group = GroupLocalServiceUtil.getGroup(groupId);
5357    
5358                            if (group.isLayout()) {
5359                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
5360                                            group.getClassPK());
5361    
5362                                    groupId = scopeLayout.getGroupId();
5363                            }
5364                    }
5365                    catch (Exception e) {
5366                    }
5367    
5368                    long plid = LayoutConstants.DEFAULT_PLID;
5369    
5370                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
5371                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
5372    
5373                    for (Layout layout : layouts) {
5374                            LayoutTypePortlet layoutTypePortlet =
5375                                    (LayoutTypePortlet)layout.getLayoutType();
5376    
5377                            if (layoutTypePortlet.hasPortletId(portletId)) {
5378                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
5379                                            plid = layout.getPlid();
5380    
5381                                            break;
5382                                    }
5383                            }
5384                    }
5385    
5386                    return plid;
5387            }
5388    
5389            protected List<Portlet> filterControlPanelPortlets(
5390                    Set<Portlet> portlets, String category, ThemeDisplay themeDisplay) {
5391    
5392                    Group group = themeDisplay.getScopeGroup();
5393    
5394                    List<Portlet> filteredPortlets = new ArrayList<Portlet>();
5395    
5396                    if (category.equals(PortletCategoryKeys.CONTENT) && group.isLayout()) {
5397                            for (Portlet portlet : portlets) {
5398                                    if (portlet.isScopeable()) {
5399                                            filteredPortlets.add(portlet);
5400                                    }
5401                            }
5402                    }
5403                    else {
5404                            filteredPortlets.addAll(portlets);
5405                    }
5406    
5407                    Iterator<Portlet> itr = filteredPortlets.iterator();
5408    
5409                    while (itr.hasNext()) {
5410                            Portlet portlet = itr.next();
5411    
5412                            try {
5413                                    ControlPanelEntry controlPanelEntry =
5414                                            portlet.getControlPanelEntryInstance();
5415    
5416                                    if (controlPanelEntry == null) {
5417                                            controlPanelEntry =
5418                                                    DefaultControlPanelEntryFactory.getInstance();
5419                                    }
5420    
5421                                    if (!controlPanelEntry.isVisible(
5422                                                    portlet, category, themeDisplay)) {
5423    
5424                                            itr.remove();
5425                                    }
5426                            }
5427                            catch (Exception e) {
5428                                    _log.error(e, e);
5429    
5430                                    itr.remove();
5431                            }
5432                    }
5433    
5434                    return filteredPortlets;
5435            }
5436    
5437            protected long getDefaultScopeGroupId(long companyId)
5438                    throws PortalException, SystemException {
5439    
5440                    long doAsGroupId = 0;
5441    
5442                    Collection<Portlet> portlets = getControlPanelPortlets(
5443                            companyId, PortletCategoryKeys.CONTENT);
5444    
5445                    List<Group> groups = GroupServiceUtil.getManageableSites(portlets, 1);
5446    
5447                    if (!groups.isEmpty()) {
5448                            Group group = groups.get(0);
5449    
5450                            doAsGroupId = group.getGroupId();
5451                    }
5452                    else {
5453                            Group guestGroup = GroupLocalServiceUtil.fetchGroup(
5454                                    companyId, GroupConstants.GUEST);
5455    
5456                            if (guestGroup != null) {
5457                                    doAsGroupId = guestGroup.getGroupId();
5458                            }
5459                    }
5460    
5461                    return doAsGroupId;
5462            }
5463    
5464            protected long getDoAsUserId(
5465                            HttpServletRequest request, String doAsUserIdString,
5466                            boolean alwaysAllowDoAsUser)
5467                    throws Exception {
5468    
5469                    if (Validator.isNull(doAsUserIdString)) {
5470                            return 0;
5471                    }
5472    
5473                    long doAsUserId = 0;
5474    
5475                    try {
5476                            Company company = getCompany(request);
5477    
5478                            doAsUserId = GetterUtil.getLong(
5479                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
5480                    }
5481                    catch (Exception e) {
5482                            if (_log.isWarnEnabled()) {
5483                                    _log.warn(
5484                                            "Unable to impersonate " + doAsUserIdString +
5485                                                    " because the string cannot be decrypted",
5486                                            e);
5487                            }
5488    
5489                            return 0;
5490                    }
5491    
5492                    if (_log.isDebugEnabled()) {
5493                            if (alwaysAllowDoAsUser) {
5494                                    _log.debug(
5495                                            "doAsUserId path or Struts action is always allowed");
5496                            }
5497                            else {
5498                                    _log.debug(
5499                                            "doAsUserId path is Struts action not always allowed");
5500                            }
5501                    }
5502    
5503                    if (alwaysAllowDoAsUser) {
5504                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
5505    
5506                            return doAsUserId;
5507                    }
5508    
5509                    HttpSession session = request.getSession();
5510    
5511                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5512    
5513                    if (realUserIdObj == null) {
5514                            return 0;
5515                    }
5516    
5517                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
5518    
5519                    long[] organizationIds = doAsUser.getOrganizationIds();
5520    
5521                    User realUser = UserLocalServiceUtil.getUserById(
5522                            realUserIdObj.longValue());
5523                    boolean checkGuest = true;
5524    
5525                    PermissionChecker permissionChecker =
5526                            PermissionCheckerFactoryUtil.create(realUser, checkGuest);
5527    
5528                    if (doAsUser.isDefaultUser() ||
5529                            UserPermissionUtil.contains(
5530                                    permissionChecker, doAsUserId, organizationIds,
5531                                    ActionKeys.IMPERSONATE)) {
5532    
5533                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
5534    
5535                            return doAsUserId;
5536                    }
5537                    else {
5538                            _log.error(
5539                                    "User " + realUserIdObj + " does not have the permission " +
5540                                            "to impersonate " + doAsUserId);
5541    
5542                            return 0;
5543                    }
5544            }
5545    
5546            protected String getGroupFriendlyURL(
5547                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
5548                            boolean canonicalURL)
5549                    throws PortalException, SystemException {
5550    
5551                    LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
5552                            group.getGroupId(), privateLayoutSet);
5553    
5554                    String portalURL = StringPool.BLANK;
5555    
5556                    if (canonicalURL || !themeDisplay.getServerName().equals(_LOCALHOST)) {
5557                            String virtualHostname = layoutSet.getVirtualHostname();
5558    
5559                            if (Validator.isNull(virtualHostname) &&
5560                                    Validator.isNotNull(
5561                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
5562                                    !layoutSet.isPrivateLayout()) {
5563    
5564                                    try {
5565                                            Group defaultGroup = GroupLocalServiceUtil.getGroup(
5566                                                    themeDisplay.getCompanyId(),
5567                                                    PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
5568    
5569                                            if (layoutSet.getGroupId() == defaultGroup.getGroupId()) {
5570                                                    Company company = themeDisplay.getCompany();
5571    
5572                                                    virtualHostname = company.getVirtualHostname();
5573                                            }
5574                                    }
5575                                    catch (Exception e) {
5576                                            _log.error(e, e);
5577                                    }
5578                            }
5579    
5580                            if (Validator.isNotNull(virtualHostname) &&
5581                                    (canonicalURL ||
5582                                            !virtualHostname.equalsIgnoreCase(_LOCALHOST))) {
5583    
5584                                    virtualHostname = getPortalURL(
5585                                            virtualHostname, themeDisplay.getServerPort(),
5586                                            themeDisplay.isSecure());
5587    
5588                                    String portalDomain = HttpUtil.getDomain(
5589                                            themeDisplay.getPortalURL());
5590    
5591                                    if (canonicalURL || virtualHostname.contains(portalDomain)) {
5592                                            String path = StringPool.BLANK;
5593    
5594                                            if (themeDisplay.isWidget()) {
5595                                                    path = PropsValues.WIDGET_SERVLET_MAPPING;
5596                                            }
5597    
5598                                            if (themeDisplay.isI18n() && !canonicalURL) {
5599                                                    path = themeDisplay.getI18nPath();
5600                                            }
5601    
5602                                            return virtualHostname.concat(_pathContext).concat(path);
5603                                    }
5604                            }
5605                            else {
5606                                    Layout curLayout = themeDisplay.getLayout();
5607    
5608                                    LayoutSet curLayoutSet = curLayout.getLayoutSet();
5609    
5610                                    if (canonicalURL ||
5611                                            ((layoutSet.getLayoutSetId() !=
5612                                                    curLayoutSet.getLayoutSetId()) &&
5613                                             (group.getClassPK() != themeDisplay.getUserId()))) {
5614    
5615                                            if (group.isControlPanel()) {
5616                                                    virtualHostname = curLayoutSet.getVirtualHostname();
5617                                            }
5618    
5619                                            if (Validator.isNull(virtualHostname) ||
5620                                                    virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
5621    
5622                                                    Company company = themeDisplay.getCompany();
5623    
5624                                                    virtualHostname = company.getVirtualHostname();
5625                                            }
5626    
5627                                            if (canonicalURL ||
5628                                                    !virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
5629    
5630                                                    portalURL = getPortalURL(
5631                                                            virtualHostname, themeDisplay.getServerPort(),
5632                                                            themeDisplay.isSecure());
5633                                            }
5634                                    }
5635                            }
5636                    }
5637    
5638                    String friendlyURL = null;
5639    
5640                    if (privateLayoutSet) {
5641                            if (group.isUser()) {
5642                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
5643                            }
5644                            else {
5645                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
5646                            }
5647                    }
5648                    else {
5649                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
5650                    }
5651    
5652                    StringBundler sb = new StringBundler(6);
5653    
5654                    sb.append(portalURL);
5655                    sb.append(_pathContext);
5656    
5657                    if (themeDisplay.isI18n() && !canonicalURL) {
5658                            sb.append(themeDisplay.getI18nPath());
5659                    }
5660    
5661                    if (themeDisplay.isWidget()) {
5662                            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
5663                    }
5664    
5665                    sb.append(friendlyURL);
5666                    sb.append(group.getFriendlyURL());
5667    
5668                    return sb.toString();
5669            }
5670    
5671            protected String getPortletParam(HttpServletRequest request, String name) {
5672                    String portletId = ParamUtil.getString(request, "p_p_id");
5673    
5674                    if (Validator.isNull(portletId)) {
5675                            return StringPool.BLANK;
5676                    }
5677    
5678                    String value = null;
5679    
5680                    int valueCount = 0;
5681    
5682                    String keyName = StringPool.UNDERLINE.concat(name);
5683    
5684                    Map<String, String[]> parameterMap = request.getParameterMap();
5685    
5686                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
5687                            String parameterName = entry.getKey();
5688    
5689                            int pos = parameterName.indexOf(keyName);
5690    
5691                            if (pos == -1) {
5692                                    continue;
5693                            }
5694    
5695                            valueCount++;
5696    
5697                            // There should never be more than one value
5698    
5699                            if (valueCount > 1) {
5700                                    return StringPool.BLANK;
5701                            }
5702    
5703                            String[] parameterValues = entry.getValue();
5704    
5705                            if ((parameterValues == null) || (parameterValues.length == 0) ||
5706                                    Validator.isNull(parameterValues[0])) {
5707    
5708                                    continue;
5709                            }
5710    
5711                            // The Struts action must be for the correct portlet
5712    
5713                            String portletId1 = parameterName.substring(1, pos);
5714    
5715                            if (portletId.equals(portletId1)) {
5716                                    value = parameterValues[0];
5717                            }
5718                    }
5719    
5720                    if (value == null) {
5721                            value = StringPool.BLANK;
5722                    }
5723    
5724                    return value;
5725            }
5726    
5727            protected String getServletURL(
5728                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
5729                    throws PortalException, SystemException {
5730    
5731                    Layout layout = themeDisplay.getLayout();
5732    
5733                    StringBundler sb = new StringBundler();
5734    
5735                    sb.append(themeDisplay.getPortalURL());
5736    
5737                    if (Validator.isNotNull(_pathContext)) {
5738                            sb.append(_pathContext);
5739                    }
5740    
5741                    if (themeDisplay.isI18n()) {
5742                            sb.append(themeDisplay.getI18nPath());
5743                    }
5744    
5745                    sb.append(servletPath);
5746    
5747                    Group group = layout.getGroup();
5748    
5749                    if (layout.isPrivateLayout()) {
5750                            if (group.isUser()) {
5751                                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
5752                            }
5753                            else {
5754                                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
5755                            }
5756                    }
5757                    else {
5758                            sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
5759                    }
5760    
5761                    sb.append(group.getFriendlyURL());
5762                    sb.append(layout.getFriendlyURL());
5763    
5764                    sb.append(FRIENDLY_URL_SEPARATOR);
5765    
5766                    FriendlyURLMapper friendlyURLMapper =
5767                            portlet.getFriendlyURLMapperInstance();
5768    
5769                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
5770                            sb.append(friendlyURLMapper.getMapping());
5771                    }
5772                    else {
5773                            sb.append(portlet.getPortletId());
5774                    }
5775    
5776                    return sb.toString();
5777            }
5778    
5779            protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
5780                    throws Exception {
5781    
5782                    String ticketKey = ParamUtil.getString(request, "ticketKey");
5783    
5784                    if (Validator.isNull(ticketKey)) {
5785                            return false;
5786                    }
5787    
5788                    Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
5789    
5790                    if (ticket == null) {
5791                            return false;
5792                    }
5793    
5794                    String className = ticket.getClassName();
5795    
5796                    if (!className.equals(User.class.getName())) {
5797                            return false;
5798                    }
5799    
5800                    long doAsUserId = 0;
5801    
5802                    try {
5803                            Company company = getCompany(request);
5804    
5805                            String doAsUserIdString = ParamUtil.getString(
5806                                    request, "doAsUserId");
5807    
5808                            if (Validator.isNotNull(doAsUserIdString)) {
5809                                    doAsUserId = GetterUtil.getLong(
5810                                            Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
5811                            }
5812                    }
5813                    catch (Exception e) {
5814                            return false;
5815                    }
5816    
5817                    if ((ticket.getClassPK() != doAsUserId) ||
5818                            (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
5819    
5820                            return false;
5821                    }
5822    
5823                    if (ticket.isExpired()) {
5824                            TicketLocalServiceUtil.deleteTicket(ticket);
5825    
5826                            return false;
5827                    }
5828    
5829                    Date expirationDate = new Date(
5830                            System.currentTimeMillis() +
5831                                    PropsValues.SESSION_TIMEOUT * Time.MINUTE);
5832    
5833                    ticket.setExpirationDate(expirationDate);
5834    
5835                    TicketLocalServiceUtil.updateTicket(ticket, false);
5836    
5837                    return true;
5838            }
5839    
5840            protected void notifyPortalPortEventListeners(int portalPort) {
5841                    for (PortalPortEventListener portalPortEventListener :
5842                                    _portalPortEventListeners) {
5843    
5844                            portalPortEventListener.portalPortConfigured(portalPort);
5845                    }
5846            }
5847    
5848            protected String removeRedirectParameter(String url) {
5849                    String queryString = HttpUtil.getQueryString(url);
5850    
5851                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
5852                            queryString);
5853    
5854                    for (String parameter : parameterMap.keySet()) {
5855                            if (parameter.endsWith("redirect")) {
5856                                    url = HttpUtil.removeParameter(url, parameter);
5857                            }
5858                    }
5859    
5860                    return url;
5861            }
5862    
5863            private static final String _J_SECURITY_CHECK = "j_security_check";
5864    
5865            private static final String _JSESSIONID = ";jsessionid=";
5866    
5867            private static final String _LOCALHOST = "localhost";
5868    
5869            private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
5870                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
5871    
5872            private static final String _PRIVATE_USER_SERVLET_MAPPING =
5873                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
5874    
5875            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
5876                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
5877    
5878            private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
5879    
5880            private static Log _logWebServerServlet = LogFactoryUtil.getLog(
5881                    WebServerServlet.class);
5882    
5883            private static Map<Long, String> _cdnHostHttpMap =
5884                    new ConcurrentHashMap<Long, String>();
5885            private static Map<Long, String> _cdnHostHttpsMap =
5886                    new ConcurrentHashMap<Long, String>();
5887            private static MethodHandler _resetCDNHostsMethodHandler =
5888                    new MethodHandler(
5889                            new MethodKey(PortalUtil.class.getName(), "resetCDNHosts"));
5890            private static Date _upTime = new Date();
5891    
5892            private String[] _allSystemGroups;
5893            private String[] _allSystemOrganizationRoles;
5894            private String[] _allSystemRoles;
5895            private String[] _allSystemSiteRoles;
5896            private Set<String> _authTokenIgnoreActions;
5897            private Set<String> _authTokenIgnorePortlets;
5898            private Pattern _bannedResourceIdPattern = Pattern.compile(
5899                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
5900                    Pattern.CASE_INSENSITIVE);
5901            private String _computerAddress;
5902            private String _computerName;
5903            private String[] _customSqlKeys;
5904            private String[] _customSqlValues;
5905            private String _pathContext;
5906            private String _pathFriendlyURLPrivateGroup;
5907            private String _pathFriendlyURLPrivateUser;
5908            private String _pathFriendlyURLPublic;
5909            private String _pathImage;
5910            private String _pathMain;
5911            private String _pathProxy;
5912            private Map<String, Long> _plidToPortletIdMap =
5913                    new ConcurrentHashMap<String, Long>();
5914            private final AtomicInteger _portalPort = new AtomicInteger(-1);
5915            private List<PortalPortEventListener> _portalPortEventListeners =
5916                    new ArrayList<PortalPortEventListener>();
5917            private Set<String> _portletAddDefaultResourceCheckWhitelist;
5918            private Set<String> _portletAddDefaultResourceCheckWhitelistActions;
5919            private Set<String> _reservedParams;
5920            private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
5921            private String[] _sortedSystemGroups;
5922            private String[] _sortedSystemOrganizationRoles;
5923            private String[] _sortedSystemRoles;
5924            private String[] _sortedSystemSiteRoles;
5925    
5926    }