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