001    /**
002     * Copyright (c) 2000-2013 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.NoSuchImageException;
018    import com.liferay.portal.NoSuchLayoutException;
019    import com.liferay.portal.NoSuchUserException;
020    import com.liferay.portal.cluster.ClusterInvokeThreadLocal;
021    import com.liferay.portal.dao.orm.common.SQLTransformer;
022    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
023    import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
024    import com.liferay.portal.kernel.cluster.ClusterRequest;
025    import com.liferay.portal.kernel.dao.db.DB;
026    import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
027    import com.liferay.portal.kernel.exception.PortalException;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.language.LanguageUtil;
030    import com.liferay.portal.kernel.log.Log;
031    import com.liferay.portal.kernel.log.LogFactoryUtil;
032    import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
033    import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
034    import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
035    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
036    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
037    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
038    import com.liferay.portal.kernel.portlet.LiferayPortletURL;
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.security.pacl.DoPrivileged;
043    import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
044    import com.liferay.portal.kernel.servlet.DynamicServletRequest;
045    import com.liferay.portal.kernel.servlet.HttpHeaders;
046    import com.liferay.portal.kernel.servlet.HttpMethods;
047    import com.liferay.portal.kernel.servlet.NonSerializableObjectRequestWrapper;
048    import com.liferay.portal.kernel.servlet.PersistentHttpServletRequestWrapper;
049    import com.liferay.portal.kernel.servlet.PortalMessages;
050    import com.liferay.portal.kernel.servlet.PortalSessionThreadLocal;
051    import com.liferay.portal.kernel.servlet.ServletContextUtil;
052    import com.liferay.portal.kernel.servlet.SessionErrors;
053    import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
054    import com.liferay.portal.kernel.upload.UploadPortletRequest;
055    import com.liferay.portal.kernel.upload.UploadServletRequest;
056    import com.liferay.portal.kernel.util.ArrayUtil;
057    import com.liferay.portal.kernel.util.Base64;
058    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
059    import com.liferay.portal.kernel.util.CharPool;
060    import com.liferay.portal.kernel.util.ContentTypes;
061    import com.liferay.portal.kernel.util.ContextPathUtil;
062    import com.liferay.portal.kernel.util.CookieKeys;
063    import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
064    import com.liferay.portal.kernel.util.GetterUtil;
065    import com.liferay.portal.kernel.util.HtmlUtil;
066    import com.liferay.portal.kernel.util.Http;
067    import com.liferay.portal.kernel.util.HttpUtil;
068    import com.liferay.portal.kernel.util.InheritableMap;
069    import com.liferay.portal.kernel.util.JavaConstants;
070    import com.liferay.portal.kernel.util.ListMergeable;
071    import com.liferay.portal.kernel.util.ListUtil;
072    import com.liferay.portal.kernel.util.LocaleUtil;
073    import com.liferay.portal.kernel.util.MethodHandler;
074    import com.liferay.portal.kernel.util.MethodKey;
075    import com.liferay.portal.kernel.util.ParamUtil;
076    import com.liferay.portal.kernel.util.PropsKeys;
077    import com.liferay.portal.kernel.util.ReleaseInfo;
078    import com.liferay.portal.kernel.util.ResourceBundleUtil;
079    import com.liferay.portal.kernel.util.ServerDetector;
080    import com.liferay.portal.kernel.util.StringBundler;
081    import com.liferay.portal.kernel.util.StringComparator;
082    import com.liferay.portal.kernel.util.StringPool;
083    import com.liferay.portal.kernel.util.StringUtil;
084    import com.liferay.portal.kernel.util.Time;
085    import com.liferay.portal.kernel.util.UnicodeProperties;
086    import com.liferay.portal.kernel.util.Validator;
087    import com.liferay.portal.kernel.xml.QName;
088    import com.liferay.portal.model.AuditedModel;
089    import com.liferay.portal.model.BaseModel;
090    import com.liferay.portal.model.ClassName;
091    import com.liferay.portal.model.ColorScheme;
092    import com.liferay.portal.model.Company;
093    import com.liferay.portal.model.Group;
094    import com.liferay.portal.model.GroupConstants;
095    import com.liferay.portal.model.Layout;
096    import com.liferay.portal.model.LayoutConstants;
097    import com.liferay.portal.model.LayoutFriendlyURLComposite;
098    import com.liferay.portal.model.LayoutQueryStringComposite;
099    import com.liferay.portal.model.LayoutSet;
100    import com.liferay.portal.model.LayoutType;
101    import com.liferay.portal.model.LayoutTypePortlet;
102    import com.liferay.portal.model.LayoutTypePortletConstants;
103    import com.liferay.portal.model.Organization;
104    import com.liferay.portal.model.Portlet;
105    import com.liferay.portal.model.PortletConstants;
106    import com.liferay.portal.model.PublicRenderParameter;
107    import com.liferay.portal.model.ResourceConstants;
108    import com.liferay.portal.model.ResourcePermission;
109    import com.liferay.portal.model.Role;
110    import com.liferay.portal.model.RoleConstants;
111    import com.liferay.portal.model.Theme;
112    import com.liferay.portal.model.Ticket;
113    import com.liferay.portal.model.TicketConstants;
114    import com.liferay.portal.model.User;
115    import com.liferay.portal.model.UserGroup;
116    import com.liferay.portal.model.VirtualLayoutConstants;
117    import com.liferay.portal.model.impl.LayoutTypePortletImpl;
118    import com.liferay.portal.model.impl.VirtualLayout;
119    import com.liferay.portal.plugin.PluginPackageUtil;
120    import com.liferay.portal.security.auth.AuthException;
121    import com.liferay.portal.security.auth.AuthTokenUtil;
122    import com.liferay.portal.security.auth.AuthTokenWhitelistUtil;
123    import com.liferay.portal.security.auth.CompanyThreadLocal;
124    import com.liferay.portal.security.auth.FullNameGenerator;
125    import com.liferay.portal.security.auth.FullNameGeneratorFactory;
126    import com.liferay.portal.security.auth.PrincipalException;
127    import com.liferay.portal.security.lang.DoPrivilegedUtil;
128    import com.liferay.portal.security.permission.ActionKeys;
129    import com.liferay.portal.security.permission.PermissionChecker;
130    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
131    import com.liferay.portal.security.permission.ResourceActionsUtil;
132    import com.liferay.portal.service.ClassNameLocalServiceUtil;
133    import com.liferay.portal.service.CompanyLocalServiceUtil;
134    import com.liferay.portal.service.GroupLocalServiceUtil;
135    import com.liferay.portal.service.GroupServiceUtil;
136    import com.liferay.portal.service.LayoutLocalServiceUtil;
137    import com.liferay.portal.service.LayoutSetLocalServiceUtil;
138    import com.liferay.portal.service.PortletLocalServiceUtil;
139    import com.liferay.portal.service.ResourceLocalServiceUtil;
140    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
141    import com.liferay.portal.service.TicketLocalServiceUtil;
142    import com.liferay.portal.service.UserLocalServiceUtil;
143    import com.liferay.portal.service.UserServiceUtil;
144    import com.liferay.portal.service.permission.GroupPermissionUtil;
145    import com.liferay.portal.service.permission.LayoutPermissionUtil;
146    import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
147    import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
148    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
149    import com.liferay.portal.service.permission.PortletPermissionUtil;
150    import com.liferay.portal.service.permission.UserPermissionUtil;
151    import com.liferay.portal.servlet.filters.i18n.I18nFilter;
152    import com.liferay.portal.servlet.filters.secure.NonceUtil;
153    import com.liferay.portal.spring.context.PortalContextLoaderListener;
154    import com.liferay.portal.struts.StrutsUtil;
155    import com.liferay.portal.theme.PortletDisplay;
156    import com.liferay.portal.theme.ThemeDisplay;
157    import com.liferay.portal.upload.UploadPortletRequestImpl;
158    import com.liferay.portal.upload.UploadServletRequestImpl;
159    import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
160    import com.liferay.portal.webserver.WebServerServlet;
161    import com.liferay.portlet.ActionResponseImpl;
162    import com.liferay.portlet.InvokerPortlet;
163    import com.liferay.portlet.PortletConfigFactoryUtil;
164    import com.liferay.portlet.PortletInstanceFactoryUtil;
165    import com.liferay.portlet.PortletPreferencesFactoryUtil;
166    import com.liferay.portlet.PortletPreferencesImpl;
167    import com.liferay.portlet.PortletPreferencesWrapper;
168    import com.liferay.portlet.PortletQNameUtil;
169    import com.liferay.portlet.PortletRequestImpl;
170    import com.liferay.portlet.PortletResponseImpl;
171    import com.liferay.portlet.PortletURLFactoryUtil;
172    import com.liferay.portlet.PortletURLImpl;
173    import com.liferay.portlet.RenderRequestImpl;
174    import com.liferay.portlet.RenderResponseImpl;
175    import com.liferay.portlet.StateAwareResponseImpl;
176    import com.liferay.portlet.UserAttributes;
177    import com.liferay.portlet.admin.util.OmniadminUtil;
178    import com.liferay.portlet.asset.model.AssetTag;
179    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
180    import com.liferay.portlet.blogs.model.BlogsEntry;
181    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
182    import com.liferay.portlet.bookmarks.model.BookmarksFolder;
183    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
184    import com.liferay.portlet.documentlibrary.model.DLFolder;
185    import com.liferay.portlet.expando.ValueDataException;
186    import com.liferay.portlet.expando.model.ExpandoBridge;
187    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
188    import com.liferay.portlet.journal.NoSuchFeedException;
189    import com.liferay.portlet.journal.asset.JournalArticleAssetRendererFactory;
190    import com.liferay.portlet.journal.model.JournalArticle;
191    import com.liferay.portlet.journal.model.JournalArticleConstants;
192    import com.liferay.portlet.journal.model.JournalFolder;
193    import com.liferay.portlet.journal.service.JournalArticleLocalServiceUtil;
194    import com.liferay.portlet.login.util.LoginUtil;
195    import com.liferay.portlet.messageboards.action.EditDiscussionAction;
196    import com.liferay.portlet.messageboards.model.MBMessage;
197    import com.liferay.portlet.messageboards.model.MBThread;
198    import com.liferay.portlet.social.model.SocialRelationConstants;
199    import com.liferay.portlet.social.util.FacebookUtil;
200    import com.liferay.portlet.wiki.model.WikiPage;
201    import com.liferay.util.Encryptor;
202    import com.liferay.util.JS;
203    
204    import java.io.IOException;
205    import java.io.Serializable;
206    
207    import java.lang.reflect.Method;
208    
209    import java.net.InetAddress;
210    import java.net.UnknownHostException;
211    
212    import java.util.ArrayList;
213    import java.util.Arrays;
214    import java.util.Calendar;
215    import java.util.Collection;
216    import java.util.Date;
217    import java.util.Enumeration;
218    import java.util.HashMap;
219    import java.util.HashSet;
220    import java.util.Iterator;
221    import java.util.LinkedHashMap;
222    import java.util.List;
223    import java.util.Locale;
224    import java.util.Map;
225    import java.util.Properties;
226    import java.util.ResourceBundle;
227    import java.util.Set;
228    import java.util.TimeZone;
229    import java.util.TreeSet;
230    import java.util.concurrent.ConcurrentHashMap;
231    import java.util.concurrent.atomic.AtomicInteger;
232    import java.util.regex.Matcher;
233    import java.util.regex.Pattern;
234    
235    import javax.portlet.ActionRequest;
236    import javax.portlet.ActionResponse;
237    import javax.portlet.PortletConfig;
238    import javax.portlet.PortletException;
239    import javax.portlet.PortletMode;
240    import javax.portlet.PortletPreferences;
241    import javax.portlet.PortletRequest;
242    import javax.portlet.PortletResponse;
243    import javax.portlet.PortletURL;
244    import javax.portlet.PreferencesValidator;
245    import javax.portlet.RenderRequest;
246    import javax.portlet.RenderResponse;
247    import javax.portlet.ValidatorException;
248    import javax.portlet.WindowState;
249    
250    import javax.servlet.RequestDispatcher;
251    import javax.servlet.ServletContext;
252    import javax.servlet.ServletException;
253    import javax.servlet.http.HttpServletRequest;
254    import javax.servlet.http.HttpServletRequestWrapper;
255    import javax.servlet.http.HttpServletResponse;
256    import javax.servlet.http.HttpSession;
257    import javax.servlet.jsp.PageContext;
258    
259    import org.apache.struts.Globals;
260    
261    /**
262     * @author Brian Wing Shun Chan
263     * @author Brian Myunghun Kim
264     * @author Jorge Ferrer
265     * @author Raymond Aug??
266     * @author Eduardo Lundgren
267     * @author Wesley Gong
268     * @author Hugo Huijser
269     * @author Juan Fern??ndez
270     */
271    @DoPrivileged
272    public class PortalImpl implements Portal {
273    
274            public PortalImpl() {
275    
276                    // Computer name
277    
278                    _computerName = System.getProperty("env.COMPUTERNAME");
279    
280                    if (Validator.isNull(_computerName)) {
281                            _computerName = System.getProperty("env.HOST");
282                    }
283    
284                    if (Validator.isNull(_computerName)) {
285                            _computerName = System.getProperty("env.HOSTNAME");
286                    }
287    
288                    if (Validator.isNull(_computerName)) {
289                            try {
290                                    _computerName = InetAddress.getLocalHost().getHostName();
291                            }
292                            catch (UnknownHostException uhe) {
293                            }
294                    }
295    
296                    try {
297                            _computerAddress = InetAddress.getByName(
298                                    _computerName).getHostAddress();
299                    }
300                    catch (UnknownHostException uhe) {
301                    }
302    
303                    if (Validator.isNull(_computerAddress)) {
304                            try {
305                                    _computerAddress = InetAddress.getLocalHost().getHostAddress();
306                            }
307                            catch (UnknownHostException uhe) {
308                            }
309                    }
310    
311                    // Paths
312    
313                    _pathProxy = PropsValues.PORTAL_PROXY_PATH;
314    
315                    _pathContext = ContextPathUtil.getContextPath(
316                            PortalContextLoaderListener.getPortalServletContextPath());
317                    _pathContext = _pathProxy.concat(_pathContext);
318    
319                    _pathFriendlyURLPrivateGroup =
320                            _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
321                    _pathFriendlyURLPrivateUser =
322                            _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
323                    _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
324                    _pathImage = _pathContext + PATH_IMAGE;
325                    _pathMain = _pathContext + PATH_MAIN;
326                    _pathModule = _pathContext + PATH_MODULE;
327    
328                    // Groups
329    
330                    String[] customSystemGroups = PropsUtil.getArray(
331                            PropsKeys.SYSTEM_GROUPS);
332    
333                    if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
334                            _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
335                    }
336                    else {
337                            _allSystemGroups = ArrayUtil.append(
338                                    GroupConstants.SYSTEM_GROUPS, customSystemGroups);
339                    }
340    
341                    _sortedSystemGroups = new String[_allSystemGroups.length];
342    
343                    System.arraycopy(
344                            _allSystemGroups, 0, _sortedSystemGroups, 0,
345                            _allSystemGroups.length);
346    
347                    Arrays.sort(_sortedSystemGroups, new StringComparator());
348    
349                    // Regular roles
350    
351                    String[] customSystemRoles = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
352    
353                    if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
354                            _allSystemRoles = RoleConstants.SYSTEM_ROLES;
355                    }
356                    else {
357                            _allSystemRoles = ArrayUtil.append(
358                                    RoleConstants.SYSTEM_ROLES, customSystemRoles);
359                    }
360    
361                    _sortedSystemRoles = new String[_allSystemRoles.length];
362    
363                    System.arraycopy(
364                            _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
365    
366                    Arrays.sort(_sortedSystemRoles, new StringComparator());
367    
368                    // Organization roles
369    
370                    String[] customSystemOrganizationRoles = PropsUtil.getArray(
371                            PropsKeys.SYSTEM_ORGANIZATION_ROLES);
372    
373                    if ((customSystemOrganizationRoles == null) ||
374                            (customSystemOrganizationRoles.length == 0)) {
375    
376                            _allSystemOrganizationRoles =
377                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES;
378                    }
379                    else {
380                            _allSystemOrganizationRoles = ArrayUtil.append(
381                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES,
382                                    customSystemOrganizationRoles);
383                    }
384    
385                    _sortedSystemOrganizationRoles =
386                            new String[_allSystemOrganizationRoles.length];
387    
388                    System.arraycopy(
389                            _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
390                            _allSystemOrganizationRoles.length);
391    
392                    Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
393    
394                    // Site roles
395    
396                    String[] customSystemSiteRoles = PropsUtil.getArray(
397                            PropsKeys.SYSTEM_SITE_ROLES);
398    
399                    if ((customSystemSiteRoles == null) ||
400                            (customSystemSiteRoles.length == 0)) {
401    
402                            _allSystemSiteRoles = RoleConstants.SYSTEM_SITE_ROLES;
403                    }
404                    else {
405                            _allSystemSiteRoles = ArrayUtil.append(
406                                    RoleConstants.SYSTEM_SITE_ROLES, customSystemSiteRoles);
407                    }
408    
409                    _sortedSystemSiteRoles = new String[_allSystemSiteRoles.length];
410    
411                    System.arraycopy(
412                            _allSystemSiteRoles, 0, _sortedSystemSiteRoles, 0,
413                            _allSystemSiteRoles.length);
414    
415                    Arrays.sort(_sortedSystemSiteRoles, new StringComparator());
416    
417                    // Reserved parameter names
418    
419                    _reservedParams = new HashSet<String>();
420    
421                    // Portal authentication
422    
423                    _reservedParams.add("p_auth");
424                    _reservedParams.add("p_auth_secret");
425    
426                    // Portal layout
427    
428                    _reservedParams.add("p_l_id");
429                    _reservedParams.add("p_l_reset");
430    
431                    // Portal portlet
432    
433                    _reservedParams.add("p_p_auth");
434                    _reservedParams.add("p_p_id");
435                    _reservedParams.add("p_p_i_id");
436                    _reservedParams.add("p_p_lifecycle");
437                    _reservedParams.add("p_p_url_type");
438                    _reservedParams.add("p_p_state");
439                    _reservedParams.add("p_p_state_rcv"); // LPS-14144
440                    _reservedParams.add("p_p_mode");
441                    _reservedParams.add("p_p_resource_id");
442                    _reservedParams.add("p_p_cacheability");
443                    _reservedParams.add("p_p_width");
444                    _reservedParams.add("p_p_col_id");
445                    _reservedParams.add("p_p_col_pos");
446                    _reservedParams.add("p_p_col_count");
447                    _reservedParams.add("p_p_static");
448                    _reservedParams.add("p_p_isolated");
449    
450                    // Portal theme
451    
452                    _reservedParams.add("p_t_lifecycle"); // LPS-14383
453    
454                    // Portal virtual layout
455    
456                    _reservedParams.add("p_v_l_s_g_id"); // LPS-23010
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            @Override
473            public void addPageDescription(
474                    String description, HttpServletRequest request) {
475    
476                    ListMergeable<String> descriptionListMergeable =
477                            (ListMergeable<String>)request.getAttribute(
478                                    WebKeys.PAGE_DESCRIPTION);
479    
480                    if (descriptionListMergeable == null) {
481                            descriptionListMergeable = new ListMergeable<String>();
482    
483                            request.setAttribute(
484                                    WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
485                    }
486    
487                    descriptionListMergeable.add(description);
488    
489            }
490    
491            @Override
492            public void addPageKeywords(String keywords, HttpServletRequest request) {
493                    ListMergeable<String> keywordsListMergeable =
494                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_KEYWORDS);
495    
496                    if (keywordsListMergeable == null) {
497                            keywordsListMergeable = new ListMergeable<String>();
498    
499                            request.setAttribute(WebKeys.PAGE_KEYWORDS, keywordsListMergeable);
500                    }
501    
502                    String[] keywordsArray = StringUtil.split(keywords);
503    
504                    for (String keyword : keywordsArray) {
505                            if (!keywordsListMergeable.contains(keyword.toLowerCase())) {
506                                    keywordsListMergeable.add(keyword.toLowerCase());
507                            }
508                    }
509            }
510    
511            @Override
512            public void addPageSubtitle(String subtitle, HttpServletRequest request) {
513                    ListMergeable<String> subtitleListMergeable =
514                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_SUBTITLE);
515    
516                    if (subtitleListMergeable == null) {
517                            subtitleListMergeable = new ListMergeable<String>();
518    
519                            request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
520                    }
521    
522                    subtitleListMergeable.add(subtitle);
523            }
524    
525            @Override
526            public void addPageTitle(String title, HttpServletRequest request) {
527                    ListMergeable<String> titleListMergeable =
528                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_TITLE);
529    
530                    if (titleListMergeable != null) {
531                            titleListMergeable = new ListMergeable<String>();
532    
533                            request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
534                    }
535    
536                    titleListMergeable.add(title);
537            }
538    
539            @Override
540            public void addPortalPortEventListener(
541                    PortalPortEventListener portalPortEventListener) {
542    
543                    if (!_portalPortEventListeners.contains(portalPortEventListener)) {
544                            _portalPortEventListeners.add(portalPortEventListener);
545                    }
546            }
547    
548            @Override
549            public void addPortletBreadcrumbEntry(
550                    HttpServletRequest request, String title, String url) {
551    
552                    addPortletBreadcrumbEntry(request, title, url, null);
553            }
554    
555            @Override
556            public void addPortletBreadcrumbEntry(
557                    HttpServletRequest request, String title, String url,
558                    Map<String, Object> data) {
559    
560                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
561                            WebKeys.THEME_DISPLAY);
562    
563                    PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
564    
565                    String name = WebKeys.PORTLET_BREADCRUMBS;
566    
567                    if (Validator.isNotNull(portletDisplay.getId()) &&
568                            !portletDisplay.isFocused()) {
569    
570                            name += StringPool.UNDERLINE + portletDisplay.getId();
571                    }
572    
573                    List<BreadcrumbEntry> breadcrumbEntries =
574                            (List<BreadcrumbEntry>)request.getAttribute(name);
575    
576                    if (breadcrumbEntries == null) {
577                            breadcrumbEntries = new ArrayList<BreadcrumbEntry>();
578    
579                            request.setAttribute(name, breadcrumbEntries);
580                    }
581    
582                    BreadcrumbEntry breadcrumbEntry = new BreadcrumbEntry();
583    
584                    breadcrumbEntry.setData(data);
585                    breadcrumbEntry.setTitle(title);
586                    breadcrumbEntry.setURL(url);
587    
588                    breadcrumbEntries.add(breadcrumbEntry);
589            }
590    
591            @Override
592            public void addPortletDefaultResource(
593                            HttpServletRequest request, Portlet portlet)
594                    throws PortalException, SystemException {
595    
596                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
597                            WebKeys.THEME_DISPLAY);
598    
599                    Layout layout = themeDisplay.getLayout();
600    
601                    long groupId = 0;
602    
603                    if (layout.isTypeControlPanel()) {
604                            groupId = themeDisplay.getScopeGroupId();
605                    }
606                    else {
607                            groupId = getScopeGroupId(layout, portlet.getPortletId());
608                    }
609    
610                    addDefaultResource(
611                            themeDisplay.getCompanyId(), groupId, layout, portlet, true);
612                    addDefaultResource(
613                            themeDisplay.getCompanyId(), groupId, layout, portlet, false);
614            }
615    
616            @Override
617            public void addPortletDefaultResource(
618                            long companyId, Layout layout, Portlet portlet)
619                    throws PortalException, SystemException {
620    
621                    addDefaultResource(companyId, layout, portlet, true);
622                    addDefaultResource(companyId, layout, portlet, false);
623            }
624    
625            @Override
626            public String addPreservedParameters(
627                    ThemeDisplay themeDisplay, Layout layout, String url,
628                    boolean doAsUser) {
629    
630                    if (doAsUser) {
631                            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
632                                    url = HttpUtil.addParameter(
633                                            url, "doAsUserId", themeDisplay.getDoAsUserId());
634                            }
635    
636                            if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
637                                    url = HttpUtil.addParameter(
638                                            url, "doAsUserLanguageId",
639                                            themeDisplay.getDoAsUserLanguageId());
640                            }
641                    }
642    
643                    if (layout.isTypeControlPanel()) {
644                            if (themeDisplay.getDoAsGroupId() > 0) {
645                                    url = HttpUtil.addParameter(
646                                            url, "doAsGroupId", themeDisplay.getDoAsGroupId());
647                            }
648    
649                            if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
650                                    url = HttpUtil.addParameter(
651                                            url, "refererPlid", themeDisplay.getRefererPlid());
652                            }
653    
654                            if (Validator.isNotNull(themeDisplay.getControlPanelCategory())) {
655                                    url = HttpUtil.addParameter(
656                                            url, "controlPanelCategory",
657                                            themeDisplay.getControlPanelCategory());
658                            }
659                    }
660    
661                    return url;
662            }
663    
664            @Override
665            public String addPreservedParameters(
666                    ThemeDisplay themeDisplay, String url) {
667    
668                    return addPreservedParameters(
669                            themeDisplay, themeDisplay.getLayout(), url, true);
670            }
671    
672            @Override
673            public void addUserLocaleOptionsMessage(HttpServletRequest request) {
674                    boolean showUserLocaleOptionsMessage = ParamUtil.getBoolean(
675                            request, "showUserLocaleOptionsMessage", true);
676    
677                    if (!showUserLocaleOptionsMessage) {
678                            return;
679                    }
680    
681                    PortalMessages.add(request, PortalMessages.KEY_ANIMATION, false);
682                    PortalMessages.add(
683                            request, PortalMessages.KEY_JSP_PATH,
684                            "/html/common/themes/user_locale_options.jsp");
685                    PortalMessages.add(request, PortalMessages.KEY_TIMEOUT, 0);
686            }
687    
688            @Override
689            public void clearRequestParameters(RenderRequest renderRequest) {
690                    RenderRequestImpl renderRequestImpl = (RenderRequestImpl)renderRequest;
691    
692                    if (renderRequestImpl.isTriggeredByActionURL()) {
693                            Map<String, String[]> renderParameters =
694                                    renderRequestImpl.getRenderParameters();
695    
696                            renderParameters.clear();
697                    }
698            }
699    
700            @Override
701            public void copyRequestParameters(
702                    ActionRequest actionRequest, ActionResponse actionResponse) {
703    
704                    if (actionResponse instanceof StateAwareResponseImpl) {
705                            StateAwareResponseImpl stateAwareResponseImpl =
706                                    (StateAwareResponseImpl)actionResponse;
707    
708                            if (stateAwareResponseImpl.getRedirectLocation() != null) {
709                                    if (_log.isDebugEnabled()) {
710                                            _log.debug(
711                                                    "Cannot copy parameters on a redirected " +
712                                                            "StateAwareResponseImpl");
713                                    }
714    
715                                    return;
716                            }
717                    }
718    
719                    ActionResponseImpl actionResponseImpl =
720                            (ActionResponseImpl)actionResponse;
721    
722                    Map<String, String[]> renderParameters =
723                            actionResponseImpl.getRenderParameterMap();
724    
725                    actionResponse.setRenderParameter("p_p_lifecycle", "1");
726    
727                    Enumeration<String> enu = actionRequest.getParameterNames();
728    
729                    while (enu.hasMoreElements()) {
730                            String param = enu.nextElement();
731                            String[] values = actionRequest.getParameterValues(param);
732    
733                            if (renderParameters.get(
734                                            actionResponseImpl.getNamespace() + param) == null) {
735    
736                                    actionResponse.setRenderParameter(param, values);
737                            }
738                    }
739            }
740    
741            @Override
742            public String escapeRedirect(String url) {
743                    if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
744                            return url;
745                    }
746    
747                    String domain = HttpUtil.getDomain(url);
748    
749                    int pos = domain.indexOf(CharPool.COLON);
750    
751                    if (pos != -1) {
752                            domain = domain.substring(0, pos);
753                    }
754    
755                    try {
756                            Company company = CompanyLocalServiceUtil.fetchCompanyByVirtualHost(
757                                    domain);
758    
759                            if (company != null) {
760                                    return url;
761                            }
762                    }
763                    catch (Exception e) {
764                    }
765    
766                    try {
767                            LayoutSet layoutSet = LayoutSetLocalServiceUtil.fetchLayoutSet(
768                                    domain);
769    
770                            if (layoutSet != null) {
771                                    return url;
772                            }
773                    }
774                    catch (Exception e) {
775                    }
776    
777                    try {
778                            String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
779    
780                            if (securityMode.equals("domain")) {
781                                    String[] allowedDomains =
782                                            PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
783    
784                                    if ((allowedDomains.length > 0) &&
785                                            !ArrayUtil.contains(allowedDomains, domain)) {
786    
787                                            if (_log.isDebugEnabled()) {
788                                                    _log.debug("Redirect URL " + url + " is not allowed");
789                                            }
790    
791                                            url = null;
792                                    }
793                            }
794                            else if (securityMode.equals("ip")) {
795                                    String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
796    
797                                    if (allowedIps.length == 0) {
798                                            return url;
799                                    }
800    
801                                    InetAddress inetAddress = InetAddress.getByName(domain);
802    
803                                    String hostAddress = inetAddress.getHostAddress();
804    
805                                    String serverIp = getComputerAddress();
806    
807                                    boolean serverIpIsHostAddress = serverIp.equals(hostAddress);
808    
809                                    for (String ip : allowedIps) {
810                                            if ((serverIpIsHostAddress && ip.equals("SERVER_IP")) ||
811                                                    ip.equals(hostAddress)) {
812    
813                                                    return url;
814                                            }
815                                    }
816    
817                                    if (_log.isDebugEnabled()) {
818                                            _log.debug("Redirect URL " + url + " is not allowed");
819                                    }
820    
821                                    url = null;
822                            }
823                    }
824                    catch (UnknownHostException uhe) {
825                            if (_log.isDebugEnabled()) {
826                                    _log.debug("Unable to determine IP for redirect URL " + url);
827                            }
828    
829                            url = null;
830                    }
831    
832                    return url;
833            }
834    
835            @Override
836            public String generateRandomKey(HttpServletRequest request, String input) {
837                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
838                            WebKeys.THEME_DISPLAY);
839    
840                    if (themeDisplay.isAjax() || themeDisplay.isIsolated() ||
841                            themeDisplay.isLifecycleResource() ||
842                            themeDisplay.isStateExclusive()) {
843    
844                            return StringUtil.randomId();
845                    }
846                    else {
847                            return DeterminateKeyGenerator.generate(input);
848                    }
849            }
850    
851            @Override
852            public String getAbsoluteURL(HttpServletRequest request, String url) {
853                    String portalURL = getPortalURL(request);
854    
855                    if (url.charAt(0) == CharPool.SLASH) {
856                            if (Validator.isNotNull(portalURL)) {
857                                    url = portalURL.concat(url);
858                            }
859                    }
860    
861                    if (!CookieKeys.hasSessionId(request) && url.startsWith(portalURL)) {
862                            url = getURLWithSessionId(url, request.getSession().getId());
863                    }
864    
865                    return url;
866            }
867    
868            @Override
869            public LayoutQueryStringComposite getActualLayoutQueryStringComposite(
870                            long groupId, boolean privateLayout, String friendlyURL,
871                            Map<String, String[]> params, Map<String, Object> requestContext)
872                    throws PortalException, SystemException {
873    
874                    Layout layout = null;
875                    String queryString = StringPool.BLANK;
876    
877                    if (Validator.isNull(friendlyURL)) {
878                            layout = LayoutLocalServiceUtil.fetchFirstLayout(
879                                    groupId, privateLayout,
880                                    LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
881    
882                            if (layout == null) {
883                                    throw new NoSuchLayoutException(
884                                            "{groupId=" + groupId + ", privateLayout=" + privateLayout +
885                                                    "}");
886                            }
887                    }
888                    else {
889                            LayoutQueryStringComposite layoutQueryStringComposite =
890                                    getPortletFriendlyURLMapperLayoutQueryStringComposite(
891                                            groupId, privateLayout, friendlyURL, params,
892                                            requestContext);
893    
894                            layout = layoutQueryStringComposite.getLayout();
895                            queryString = layoutQueryStringComposite.getQueryString();
896                    }
897    
898                    return new LayoutQueryStringComposite(layout, queryString);
899            }
900    
901            @Override
902            public String getActualURL(
903                            long groupId, boolean privateLayout, String mainPath,
904                            String friendlyURL, Map<String, String[]> params,
905                            Map<String, Object> requestContext)
906                    throws PortalException, SystemException {
907    
908                    String actualURL = null;
909    
910                    if (friendlyURL != null) {
911                            if (friendlyURL.startsWith(
912                                            JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
913    
914                                    try {
915                                            actualURL = getJournalArticleActualURL(
916                                                    groupId, privateLayout, mainPath, friendlyURL, params,
917                                                    requestContext);
918                                    }
919                                    catch (Exception e) {
920                                            throw new NoSuchLayoutException(e);
921                                    }
922                            }
923                            else if (friendlyURL.startsWith(
924                                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
925    
926                                    try {
927                                            actualURL = getVirtualLayoutActualURL(
928                                                    groupId, privateLayout, mainPath, friendlyURL, params,
929                                                    requestContext);
930                                    }
931                                    catch (Exception e) {
932                                            throw new NoSuchLayoutException(e);
933                                    }
934                            }
935                    }
936    
937                    if (actualURL == null) {
938                            actualURL = getLayoutActualURL(
939                                    groupId, privateLayout, mainPath, friendlyURL, params,
940                                    requestContext);
941                    }
942    
943                    return actualURL;
944            }
945    
946            /**
947             * @deprecated As of 6.2.0, replaced by {@link
948             *             LanguageUtil#getAvailableLocales}
949             */
950            @Override
951            public Locale[] getAlternateLocales(HttpServletRequest request) {
952                    return LanguageUtil.getAvailableLocales();
953            }
954    
955            @Override
956            public String getAlternateURL(
957                            String canonicalURL, ThemeDisplay themeDisplay, Locale locale,
958                            Layout layout)
959                    throws PortalException, SystemException {
960    
961                    LayoutSet layoutSet = themeDisplay.getLayoutSet();
962    
963                    String virtualHost = null;
964    
965                    if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
966                            virtualHost = layoutSet.getVirtualHostname();
967                    }
968                    else {
969                            Company company = themeDisplay.getCompany();
970    
971                            virtualHost = company.getVirtualHostname();
972                    }
973    
974                    String i18nPath = buildI18NPath(locale);
975    
976                    if (Validator.isNull(virtualHost)) {
977                            return canonicalURL.replaceFirst(
978                                    _PUBLIC_GROUP_SERVLET_MAPPING,
979                                    i18nPath.concat(_PUBLIC_GROUP_SERVLET_MAPPING));
980                    }
981    
982                    // www.liferay.com:8080/ctx/page to www.liferay.com:8080/ctx/es/page
983    
984                    int pos = canonicalURL.indexOf(virtualHost);
985    
986                    if (pos > 0) {
987                            pos = canonicalURL.indexOf(
988                                    CharPool.SLASH, pos + virtualHost.length());
989    
990                            if (Validator.isNotNull(_pathContext)) {
991                                    pos = canonicalURL.indexOf(
992                                            CharPool.SLASH, pos + _pathContext.length());
993                            }
994    
995                            if ((pos > 0) && (pos < canonicalURL.length())) {
996                                    String friendlyURL = canonicalURL.substring(pos);
997    
998                                    int[] friendlyURLIndex = getGroupFriendlyURLIndex(friendlyURL);
999    
1000                                    if (friendlyURLIndex != null) {
1001                                            int y = friendlyURLIndex[1];
1002    
1003                                            friendlyURL = friendlyURL.substring(y);
1004    
1005                                            if (friendlyURL.equals(StringPool.SLASH)) {
1006                                                    friendlyURL = StringPool.BLANK;
1007                                            }
1008                                    }
1009    
1010                                    if (Validator.isNotNull(friendlyURL)) {
1011                                            String canonicalURLPrefix = canonicalURL.substring(0, pos);
1012    
1013                                            String canonicalURLSuffix = canonicalURL.substring(pos);
1014    
1015                                            canonicalURLSuffix = StringUtil.replaceFirst(
1016                                                    canonicalURLSuffix, friendlyURL,
1017                                                    layout.getFriendlyURL(locale));
1018    
1019                                            canonicalURL = canonicalURLPrefix.concat(
1020                                                    canonicalURLSuffix);
1021                                    }
1022    
1023                                    Locale siteDefaultLocale = getSiteDefaultLocale(
1024                                            layout.getGroupId());
1025    
1026                                    if (siteDefaultLocale.equals(locale)) {
1027                                            return canonicalURL;
1028                                    }
1029    
1030                                    return canonicalURL.substring(0, pos).concat(
1031                                            i18nPath).concat(canonicalURL.substring(pos));
1032                            }
1033                    }
1034    
1035                    return canonicalURL.concat(i18nPath);
1036            }
1037    
1038            /**
1039             * @deprecated As of 6.2.0, replaced by {@link
1040             *             AuthTokenWhitelistUtil#getPortletCSRFWhitelistActions}
1041             */
1042            @Override
1043            public Set<String> getAuthTokenIgnoreActions() {
1044                    return AuthTokenWhitelistUtil.getPortletCSRFWhitelistActions();
1045            }
1046    
1047            /**
1048             * @deprecated As of 6.2.0, replaced by {@link
1049             *             AuthTokenWhitelistUtil#getPortletCSRFWhitelist}
1050             */
1051            @Override
1052            public Set<String> getAuthTokenIgnorePortlets() {
1053                    return AuthTokenWhitelistUtil.getPortletCSRFWhitelist();
1054            }
1055    
1056            @Override
1057            public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
1058                    throws PortalException, SystemException {
1059    
1060                    String modelName = resourcePermission.getName();
1061                    String primKey = resourcePermission.getPrimKey();
1062    
1063                    return getBaseModel(modelName, primKey);
1064            }
1065    
1066            @Override
1067            public BaseModel<?> getBaseModel(String modelName, String primKey)
1068                    throws PortalException, SystemException {
1069    
1070                    if (!modelName.contains(".model.")) {
1071                            return null;
1072                    }
1073    
1074                    String[] parts = StringUtil.split(modelName, CharPool.PERIOD);
1075    
1076                    if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
1077                            return null;
1078                    }
1079    
1080                    parts[parts.length - 2] = "service";
1081    
1082                    String serviceName =
1083                            StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
1084                    String methodName = "get" + parts[parts.length - 1];
1085    
1086                    Method method = null;
1087    
1088                    try {
1089                            Class<?> serviceUtil = Class.forName(serviceName);
1090    
1091                            if (Validator.isNumber(primKey)) {
1092                                    method = serviceUtil.getMethod(
1093                                            methodName, new Class[] {Long.TYPE});
1094    
1095                                    return (BaseModel<?>)method.invoke(null, new Long(primKey));
1096                            }
1097                            else {
1098                                    method = serviceUtil.getMethod(
1099                                            methodName, new Class[] {String.class});
1100    
1101                                    return (BaseModel<?>)method.invoke(null, primKey);
1102                            }
1103                    }
1104                    catch (Exception e) {
1105                            Throwable cause = e.getCause();
1106    
1107                            if (cause instanceof PortalException) {
1108                                    throw (PortalException)cause;
1109                            }
1110                            else if (cause instanceof SystemException) {
1111                                    throw (SystemException)cause;
1112                            }
1113                            else {
1114                                    throw new SystemException(cause);
1115                            }
1116                    }
1117            }
1118    
1119            @Override
1120            public long getBasicAuthUserId(HttpServletRequest request)
1121                    throws PortalException, SystemException {
1122    
1123                    long companyId = PortalInstances.getCompanyId(request);
1124    
1125                    return getBasicAuthUserId(request, companyId);
1126            }
1127    
1128            @Override
1129            public long getBasicAuthUserId(HttpServletRequest request, long companyId)
1130                    throws PortalException, SystemException {
1131    
1132                    long userId = 0;
1133    
1134                    String authorizationHeader = request.getHeader(
1135                            HttpHeaders.AUTHORIZATION);
1136    
1137                    if (Validator.isNull(authorizationHeader)) {
1138                            return userId;
1139                    }
1140    
1141                    String[] authorizationArray = authorizationHeader.split("\\s+");
1142    
1143                    String authorization = authorizationArray[0];
1144                    String credentials = new String(Base64.decode(authorizationArray[1]));
1145    
1146                    if (!authorization.equalsIgnoreCase(HttpServletRequest.BASIC_AUTH)) {
1147                            return userId;
1148                    }
1149    
1150                    String[] loginAndPassword = StringUtil.split(
1151                            credentials, CharPool.COLON);
1152    
1153                    String login = HttpUtil.decodeURL(loginAndPassword[0].trim());
1154    
1155                    String password = null;
1156    
1157                    if (loginAndPassword.length > 1) {
1158                            password = loginAndPassword[1].trim();
1159                    }
1160    
1161                    // Strip @uid and @sn for backwards compatibility
1162    
1163                    if (login.endsWith("@uid")) {
1164                            int pos = login.indexOf("@uid");
1165    
1166                            login = login.substring(0, pos);
1167                    }
1168                    else if (login.endsWith("@sn")) {
1169                            int pos = login.indexOf("@sn");
1170    
1171                            login = login.substring(0, pos);
1172                    }
1173    
1174                    try {
1175                            userId = LoginUtil.getAuthenticatedUserId(
1176                                    request, login, password, null);
1177                    }
1178                    catch (AuthException ae) {
1179                    }
1180    
1181                    return userId;
1182            }
1183    
1184            @Override
1185            public String getCanonicalURL(
1186                            String completeURL, ThemeDisplay themeDisplay, Layout layout)
1187                    throws PortalException, SystemException {
1188    
1189                    return getCanonicalURL(completeURL, themeDisplay, layout, false);
1190            }
1191    
1192            @Override
1193            public String getCanonicalURL(
1194                            String completeURL, ThemeDisplay themeDisplay, Layout layout,
1195                            boolean forceLayoutFriendlyURL)
1196                    throws PortalException, SystemException {
1197    
1198                    String groupFriendlyURL = StringPool.BLANK;
1199                    String parametersURL = StringPool.BLANK;
1200    
1201                    if (Validator.isNotNull(completeURL)) {
1202                            completeURL = removeRedirectParameter(completeURL);
1203    
1204                            int pos = completeURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
1205    
1206                            if (pos == -1) {
1207                                    pos = completeURL.indexOf(StringPool.QUESTION);
1208                            }
1209    
1210                            groupFriendlyURL = completeURL;
1211    
1212                            if (pos != -1) {
1213                                    groupFriendlyURL = completeURL.substring(0, pos);
1214                                    parametersURL = completeURL.substring(pos);
1215                            }
1216                    }
1217    
1218                    if (layout == null) {
1219                            layout = themeDisplay.getLayout();
1220                    }
1221    
1222                    String canonicalLayoutFriendlyURL = StringPool.BLANK;
1223    
1224                    String layoutFriendlyURL = layout.getFriendlyURL(
1225                            getSiteDefaultLocale(layout.getGroupId()));
1226    
1227                    if ((groupFriendlyURL.contains(layoutFriendlyURL) ||
1228                             groupFriendlyURL.contains(
1229                                    StringPool.SLASH + layout.getLayoutId())) &&
1230                            (!layout.isFirstParent() || Validator.isNotNull(parametersURL))) {
1231    
1232                            canonicalLayoutFriendlyURL = layoutFriendlyURL;
1233                    }
1234                    else if (forceLayoutFriendlyURL) {
1235                            canonicalLayoutFriendlyURL = layoutFriendlyURL;
1236                    }
1237    
1238                    Group group = layout.getGroup();
1239    
1240                    groupFriendlyURL = getGroupFriendlyURL(
1241                            group, layout.isPrivateLayout(), themeDisplay, true);
1242    
1243                    return groupFriendlyURL.concat(canonicalLayoutFriendlyURL).concat(
1244                            parametersURL);
1245            }
1246    
1247            /**
1248             * @deprecated As of 6.1.0, replaced by {@link #getCDNHost(boolean)}
1249             */
1250            @Override
1251            public String getCDNHost() {
1252                    long companyId = CompanyThreadLocal.getCompanyId();
1253    
1254                    return getCDNHostHttp(companyId);
1255            }
1256    
1257            @Override
1258            public String getCDNHost(boolean secure) {
1259                    long companyId = CompanyThreadLocal.getCompanyId();
1260    
1261                    if (secure) {
1262                            return getCDNHostHttps(companyId);
1263                    }
1264                    else {
1265                            return getCDNHostHttp(companyId);
1266                    }
1267            }
1268    
1269            @Override
1270            public String getCDNHost(HttpServletRequest request)
1271                    throws PortalException, SystemException {
1272    
1273                    boolean cdnEnabled = ParamUtil.getBoolean(request, "cdn_enabled", true);
1274    
1275                    if (!cdnEnabled) {
1276                            return StringPool.BLANK;
1277                    }
1278    
1279                    String cdnHost = null;
1280    
1281                    Company company = getCompany(request);
1282    
1283                    if (request.isSecure()) {
1284                            cdnHost = getCDNHostHttps(company.getCompanyId());
1285                    }
1286                    else {
1287                            cdnHost = getCDNHostHttp(company.getCompanyId());
1288                    }
1289    
1290                    if (Validator.isUrl(cdnHost)) {
1291                            return cdnHost;
1292                    }
1293    
1294                    return StringPool.BLANK;
1295            }
1296    
1297            @Override
1298            public String getCDNHostHttp(long companyId) {
1299                    String cdnHostHttp = _cdnHostHttpMap.get(companyId);
1300    
1301                    if (cdnHostHttp != null) {
1302                            return cdnHostHttp;
1303                    }
1304    
1305                    try {
1306                            cdnHostHttp = PrefsPropsUtil.getString(
1307                                    companyId, PropsKeys.CDN_HOST_HTTP, PropsValues.CDN_HOST_HTTP);
1308                    }
1309                    catch (Exception e) {
1310                    }
1311    
1312                    if ((cdnHostHttp == null) || cdnHostHttp.startsWith("${") ||
1313                            !Validator.isUrl(cdnHostHttp)) {
1314    
1315                            cdnHostHttp = StringPool.BLANK;
1316                    }
1317    
1318                    _cdnHostHttpMap.put(companyId, cdnHostHttp);
1319    
1320                    return cdnHostHttp;
1321            }
1322    
1323            @Override
1324            public String getCDNHostHttps(long companyId) {
1325                    String cdnHostHttps = _cdnHostHttpsMap.get(companyId);
1326    
1327                    if (cdnHostHttps != null) {
1328                            return cdnHostHttps;
1329                    }
1330    
1331                    try {
1332                            cdnHostHttps = PrefsPropsUtil.getString(
1333                                    companyId, PropsKeys.CDN_HOST_HTTPS,
1334                                    PropsValues.CDN_HOST_HTTPS);
1335                    }
1336                    catch (SystemException se) {
1337                    }
1338    
1339                    if ((cdnHostHttps == null) || cdnHostHttps.startsWith("${") ||
1340                            !Validator.isUrl(cdnHostHttps)) {
1341    
1342                            cdnHostHttps = StringPool.BLANK;
1343                    }
1344    
1345                    _cdnHostHttpsMap.put(companyId, cdnHostHttps);
1346    
1347                    return cdnHostHttps;
1348            }
1349    
1350            @Override
1351            public String getClassName(long classNameId) {
1352                    try {
1353                            ClassName className = ClassNameLocalServiceUtil.getClassName(
1354                                    classNameId);
1355    
1356                            return className.getValue();
1357                    }
1358                    catch (Exception e) {
1359                            throw new RuntimeException(
1360                                    "Unable to get class name from id " + classNameId);
1361                    }
1362            }
1363    
1364            @Override
1365            public long getClassNameId(Class<?> clazz) {
1366                    return ClassNameLocalServiceUtil.getClassNameId(clazz);
1367            }
1368    
1369            @Override
1370            public long getClassNameId(String value) {
1371                    return ClassNameLocalServiceUtil.getClassNameId(value);
1372            }
1373    
1374            @Override
1375            public String getClassNamePortletId(String className) {
1376                    String portletId = StringPool.BLANK;
1377    
1378                    if (className.startsWith("com.liferay.portlet.blogs")) {
1379                            portletId = PortletKeys.BLOGS;
1380                    }
1381                    else if (className.startsWith("com.liferay.portlet.bookmarks")) {
1382                            portletId = PortletKeys.BOOKMARKS;
1383                    }
1384                    else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
1385                            portletId = PortletKeys.DOCUMENT_LIBRARY;
1386                    }
1387                    else if (className.startsWith("com.liferay.portlet.imagegallery")) {
1388                            portletId = PortletKeys.MEDIA_GALLERY_DISPLAY;
1389                    }
1390                    else if (className.startsWith("com.liferay.portlet.journal")) {
1391                            portletId = PortletKeys.JOURNAL;
1392                    }
1393                    else if (className.startsWith("com.liferay.portlet.messageboards")) {
1394                            portletId = PortletKeys.MESSAGE_BOARDS;
1395                    }
1396                    else if (className.startsWith("com.liferay.portlet.wiki")) {
1397                            portletId = PortletKeys.WIKI;
1398                    }
1399    
1400                    return portletId;
1401            }
1402    
1403            @Override
1404            public Company getCompany(HttpServletRequest request)
1405                    throws PortalException, SystemException {
1406    
1407                    long companyId = getCompanyId(request);
1408    
1409                    if (companyId <= 0) {
1410                            return null;
1411                    }
1412    
1413                    Company company = (Company)request.getAttribute(WebKeys.COMPANY);
1414    
1415                    if (company == null) {
1416    
1417                            // LEP-5994
1418    
1419                            company = CompanyLocalServiceUtil.fetchCompanyById(companyId);
1420    
1421                            if (company == null) {
1422                                    company = CompanyLocalServiceUtil.getCompanyById(
1423                                            PortalInstances.getDefaultCompanyId());
1424                            }
1425    
1426                            request.setAttribute(WebKeys.COMPANY, company);
1427                    }
1428    
1429                    return company;
1430            }
1431    
1432            @Override
1433            public Company getCompany(PortletRequest portletRequest)
1434                    throws PortalException, SystemException {
1435    
1436                    return getCompany(getHttpServletRequest(portletRequest));
1437            }
1438    
1439            @Override
1440            public long getCompanyId(HttpServletRequest request) {
1441                    return PortalInstances.getCompanyId(request);
1442            }
1443    
1444            @Override
1445            public long getCompanyId(PortletRequest portletRequest) {
1446                    return getCompanyId(getHttpServletRequest(portletRequest));
1447            }
1448    
1449            @Override
1450            public long[] getCompanyIds() {
1451                    return PortalInstances.getCompanyIds();
1452            }
1453    
1454            @Override
1455            public String getComputerAddress() {
1456                    return _computerAddress;
1457            }
1458    
1459            @Override
1460            public String getComputerName() {
1461                    return _computerName;
1462            }
1463    
1464            @Override
1465            public Map<String, List<Portlet>> getControlPanelCategoriesMap(
1466                            HttpServletRequest request)
1467                    throws SystemException {
1468    
1469                    return getCategoriesMap(
1470                            request, WebKeys.CONTROL_PANEL_CATEGORIES_MAP,
1471                            PortletCategoryKeys.ALL);
1472            }
1473    
1474            @Override
1475            public String getControlPanelCategory(
1476                            String portletId, ThemeDisplay themeDisplay)
1477                    throws SystemException {
1478    
1479                    for (String category : PortletCategoryKeys.ALL) {
1480                            List<Portlet> portlets = getControlPanelPortlets(
1481                                    category, themeDisplay);
1482    
1483                            for (Portlet portlet : portlets) {
1484                                    if (portlet.getPortletId().equals(portletId)) {
1485                                            return category;
1486                                    }
1487                            }
1488                    }
1489    
1490                    return StringPool.BLANK;
1491            }
1492    
1493            @Override
1494            public String getControlPanelFullURL(
1495                            long scopeGroupId, String ppid, Map<String, String[]> params)
1496                    throws PortalException, SystemException {
1497    
1498                    StringBundler sb = new StringBundler(6);
1499    
1500                    Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1501    
1502                    Company company = CompanyLocalServiceUtil.getCompany(
1503                            group.getCompanyId());
1504    
1505                    sb.append(
1506                            getPortalURL(
1507                                    company.getVirtualHostname(), getPortalPort(false), false));
1508                    sb.append(getPathFriendlyURLPrivateGroup());
1509                    sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1510                    sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1511    
1512                    if (params != null) {
1513                            params = new HashMap<String, String[]>(params);
1514                    }
1515                    else {
1516                            params = new HashMap<String, String[]>();
1517                    }
1518    
1519                    params.put("p_p_id", new String[] {ppid});
1520                    params.put("p_p_lifecycle", new String[] {"0"});
1521                    params.put(
1522                            "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1523                    params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1524    
1525                    sb.append(HttpUtil.parameterMapToString(params, true));
1526    
1527                    return sb.toString();
1528            }
1529    
1530            @Override
1531            public long getControlPanelPlid(long companyId)
1532                    throws PortalException, SystemException {
1533    
1534                    Group controlPanelGroup = GroupLocalServiceUtil.getGroup(
1535                            companyId, GroupConstants.CONTROL_PANEL);
1536    
1537                    return LayoutLocalServiceUtil.getDefaultPlid(
1538                            controlPanelGroup.getGroupId(), true);
1539            }
1540    
1541            @Override
1542            public long getControlPanelPlid(PortletRequest portletRequest)
1543                    throws PortalException, SystemException {
1544    
1545                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1546                            WebKeys.THEME_DISPLAY);
1547    
1548                    return getControlPanelPlid(themeDisplay.getCompanyId());
1549            }
1550    
1551            @Override
1552            public Set<Portlet> getControlPanelPortlets(long companyId, String category)
1553                    throws SystemException {
1554    
1555                    Set<Portlet> portletsSet = new TreeSet<Portlet>(
1556                            new PortletControlPanelWeightComparator());
1557    
1558                    if (Validator.isNull(category)) {
1559                            return portletsSet;
1560                    }
1561    
1562                    List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1563                            companyId);
1564    
1565                    for (Portlet portlet : portletsList) {
1566                            String portletCategory = portlet.getControlPanelEntryCategory();
1567    
1568                            if (category.equals(portletCategory) ||
1569                                    (category.endsWith(StringPool.PERIOD) &&
1570                                     StringUtil.startsWith(portletCategory, category))) {
1571    
1572                                    portletsSet.add(portlet);
1573                            }
1574                    }
1575    
1576                    return portletsSet;
1577            }
1578    
1579            @Override
1580            public List<Portlet> getControlPanelPortlets(
1581                            String category, ThemeDisplay themeDisplay)
1582                    throws SystemException {
1583    
1584                    Set<Portlet> portlets = getControlPanelPortlets(
1585                            themeDisplay.getCompanyId(), category);
1586    
1587                    return filterControlPanelPortlets(portlets, themeDisplay);
1588            }
1589    
1590            @Override
1591            public PortletURL getControlPanelPortletURL(
1592                    HttpServletRequest request, String portletId, long referrerPlid,
1593                    String lifecycle) {
1594    
1595                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1596                            WebKeys.THEME_DISPLAY);
1597    
1598                    long plid = 0;
1599    
1600                    try {
1601                            plid = getControlPanelPlid(themeDisplay.getCompanyId());
1602                    }
1603                    catch (Exception e) {
1604                            _log.error("Unable to determine control panel layout id", e);
1605                    }
1606    
1607                    LiferayPortletURL liferayPortletURL = new PortletURLImpl(
1608                            request, portletId, plid, lifecycle);
1609    
1610                    liferayPortletURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
1611                    liferayPortletURL.setRefererPlid(themeDisplay.getPlid());
1612    
1613                    return liferayPortletURL;
1614            }
1615    
1616            @Override
1617            public PortletURL getControlPanelPortletURL(
1618                    PortletRequest portletRequest, String portletId, long referrerPlid,
1619                    String lifecycle) {
1620    
1621                    ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1622                            WebKeys.THEME_DISPLAY);
1623    
1624                    long plid = 0;
1625    
1626                    try {
1627                            plid = getControlPanelPlid(themeDisplay.getCompanyId());
1628                    }
1629                    catch (Exception e) {
1630                            _log.error("Unable to determine control panel layout id", e);
1631                    }
1632    
1633                    LiferayPortletURL liferayPortletURL = new PortletURLImpl(
1634                            portletRequest, portletId, plid, lifecycle);
1635    
1636                    liferayPortletURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
1637                    liferayPortletURL.setRefererPlid(themeDisplay.getPlid());
1638    
1639                    return liferayPortletURL;
1640            }
1641    
1642            @Override
1643            public String getCreateAccountURL(
1644                            HttpServletRequest request, ThemeDisplay themeDisplay)
1645                    throws Exception {
1646    
1647                    if (Validator.isNull(PropsValues.COMPANY_SECURITY_STRANGERS_URL)) {
1648                            PortletURL createAccountURL = PortletURLFactoryUtil.create(
1649                                    request, PortletKeys.LOGIN, themeDisplay.getPlid(),
1650                                    PortletRequest.RENDER_PHASE);
1651    
1652                            createAccountURL.setParameter(
1653                                    "saveLastPath", Boolean.FALSE.toString());
1654                            createAccountURL.setParameter(
1655                                    "struts_action", "/login/create_account");
1656                            createAccountURL.setPortletMode(PortletMode.VIEW);
1657                            createAccountURL.setWindowState(WindowState.MAXIMIZED);
1658    
1659                            if (!PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS) {
1660                                    return createAccountURL.toString();
1661                            }
1662    
1663                            String portalURL = getPortalURL(request);
1664                            String portalURLSecure = getPortalURL(request, true);
1665    
1666                            return StringUtil.replaceFirst(
1667                                    createAccountURL.toString(), portalURL, portalURLSecure);
1668                    }
1669    
1670                    try {
1671                            Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1672                                    themeDisplay.getScopeGroupId(), false,
1673                                    PropsValues.COMPANY_SECURITY_STRANGERS_URL);
1674    
1675                            return getLayoutURL(layout, themeDisplay);
1676                    }
1677                    catch (NoSuchLayoutException nsle) {
1678                    }
1679    
1680                    return StringPool.BLANK;
1681            }
1682    
1683            @Override
1684            public String getCurrentCompleteURL(HttpServletRequest request) {
1685                    String currentCompleteURL = (String)request.getAttribute(
1686                            WebKeys.CURRENT_COMPLETE_URL);
1687    
1688                    if (currentCompleteURL == null) {
1689                            currentCompleteURL = HttpUtil.getCompleteURL(request);
1690    
1691                            request.setAttribute(
1692                                    WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1693                    }
1694    
1695                    return currentCompleteURL;
1696            }
1697    
1698            @Override
1699            public String getCurrentURL(HttpServletRequest request) {
1700                    String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1701    
1702                    if (currentURL != null) {
1703                            return currentURL;
1704                    }
1705    
1706                    currentURL = ParamUtil.getString(request, "currentURL");
1707    
1708                    if (Validator.isNull(currentURL)) {
1709                            currentURL = HttpUtil.getCompleteURL(request);
1710    
1711                            if (Validator.isNotNull(currentURL) &&
1712                                    !currentURL.contains(_J_SECURITY_CHECK)) {
1713    
1714                                    currentURL = currentURL.substring(
1715                                            currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1716                                                    Http.PROTOCOL_DELIMITER.length());
1717    
1718                                    currentURL = currentURL.substring(
1719                                            currentURL.indexOf(CharPool.SLASH));
1720                            }
1721    
1722                            if (Validator.isNotNull(currentURL) &&
1723                                    FacebookUtil.isFacebook(currentURL)) {
1724    
1725                                    String[] facebookData = FacebookUtil.getFacebookData(request);
1726    
1727                                    if (facebookData != null) {
1728                                            currentURL =
1729                                                    FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1730                                                            facebookData[2];
1731                                    }
1732                            }
1733                    }
1734    
1735                    if (Validator.isNull(currentURL)) {
1736                            currentURL = getPathMain();
1737                    }
1738    
1739                    request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1740    
1741                    return currentURL;
1742            }
1743    
1744            @Override
1745            public String getCurrentURL(PortletRequest portletRequest) {
1746                    return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1747            }
1748    
1749            @Override
1750            public String getCustomSQLFunctionIsNotNull() {
1751                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1752            }
1753    
1754            @Override
1755            public String getCustomSQLFunctionIsNull() {
1756                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1757            }
1758    
1759            @Override
1760            public Date getDate(int month, int day, int year) {
1761                    try {
1762                            return getDate(month, day, year, null);
1763                    }
1764                    catch (PortalException pe) {
1765                            throw new RuntimeException();
1766                    }
1767            }
1768    
1769            @Override
1770            public Date getDate(
1771                            int month, int day, int year,
1772                            Class<? extends PortalException> clazz)
1773                    throws PortalException {
1774    
1775                    return getDate(month, day, year, null, clazz);
1776            }
1777    
1778            @Override
1779            public Date getDate(
1780                            int month, int day, int year, int hour, int min,
1781                            Class<? extends PortalException> clazz)
1782                    throws PortalException {
1783    
1784                    return getDate(month, day, year, hour, min, null, clazz);
1785            }
1786    
1787            @Override
1788            public Date getDate(
1789                            int month, int day, int year, int hour, int min, TimeZone timeZone,
1790                            Class<? extends PortalException> clazz)
1791                    throws PortalException {
1792    
1793                    if (!Validator.isGregorianDate(month, day, year)) {
1794                            if (clazz != null) {
1795                                    try {
1796                                            throw clazz.newInstance();
1797                                    }
1798                                    catch (Exception e) {
1799                                            throw new PortalException(e);
1800                                    }
1801                            }
1802                            else {
1803                                    return null;
1804                            }
1805                    }
1806                    else {
1807                            Calendar cal = null;
1808    
1809                            if (timeZone == null) {
1810                                    cal = CalendarFactoryUtil.getCalendar();
1811                            }
1812                            else {
1813                                    cal = CalendarFactoryUtil.getCalendar(timeZone);
1814                            }
1815    
1816                            if ((hour == -1) || (min == -1)) {
1817                                    cal.set(year, month, day, 0, 0, 0);
1818                            }
1819                            else {
1820                                    cal.set(year, month, day, hour, min, 0);
1821                            }
1822    
1823                            cal.set(Calendar.MILLISECOND, 0);
1824    
1825                            Date date = cal.getTime();
1826    
1827                            /*if ((timeZone != null) &&
1828                                    cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
1829    
1830                                    throw pe;
1831                            }*/
1832    
1833                            return date;
1834                    }
1835            }
1836    
1837            @Override
1838            public Date getDate(
1839                            int month, int day, int year, TimeZone timeZone,
1840                            Class<? extends PortalException> clazz)
1841                    throws PortalException {
1842    
1843                    return getDate(month, day, year, -1, -1, timeZone, clazz);
1844            }
1845    
1846            @Override
1847            public long getDefaultCompanyId() {
1848                    return PortalInstances.getDefaultCompanyId();
1849            }
1850    
1851            @Override
1852            public long getDigestAuthUserId(HttpServletRequest request)
1853                    throws PortalException, SystemException {
1854    
1855                    long userId = 0;
1856    
1857                    String authorizationHeader = request.getHeader(
1858                            HttpHeaders.AUTHORIZATION);
1859    
1860                    if (Validator.isNull(authorizationHeader) ||
1861                            !authorizationHeader.startsWith("Digest ")) {
1862    
1863                            return userId;
1864                    }
1865    
1866                    authorizationHeader = authorizationHeader.substring("Digest ".length());
1867                    authorizationHeader = StringUtil.replace(
1868                            authorizationHeader, CharPool.COMMA, CharPool.NEW_LINE);
1869    
1870                    UnicodeProperties authorizationProperties = new UnicodeProperties();
1871    
1872                    authorizationProperties.fastLoad(authorizationHeader);
1873    
1874                    String username = StringUtil.unquote(
1875                            authorizationProperties.getProperty("username"));
1876                    String realm = StringUtil.unquote(
1877                            authorizationProperties.getProperty("realm"));
1878                    String nonce = StringUtil.unquote(
1879                            authorizationProperties.getProperty("nonce"));
1880                    String uri = StringUtil.unquote(
1881                            authorizationProperties.getProperty("uri"));
1882                    String response = StringUtil.unquote(
1883                            authorizationProperties.getProperty("response"));
1884    
1885                    if (Validator.isNull(username) || Validator.isNull(realm) ||
1886                            Validator.isNull(nonce) || Validator.isNull(uri) ||
1887                            Validator.isNull(response)) {
1888    
1889                            return userId;
1890                    }
1891    
1892                    if (!realm.equals(PORTAL_REALM) ||
1893                            !uri.equals(request.getRequestURI())) {
1894    
1895                            return userId;
1896                    }
1897    
1898                    if (!NonceUtil.verify(nonce)) {
1899                            return userId;
1900                    }
1901    
1902                    long companyId = PortalInstances.getCompanyId(request);
1903    
1904                    userId = UserLocalServiceUtil.authenticateForDigest(
1905                            companyId, username, realm, nonce, request.getMethod(), uri,
1906                            response);
1907    
1908                    return userId;
1909            }
1910    
1911            @Override
1912            public String getEmailFromAddress(
1913                            PortletPreferences preferences, long companyId, String defaultValue)
1914                    throws SystemException {
1915    
1916                    if (Validator.isNull(defaultValue)) {
1917                            defaultValue = PrefsPropsUtil.getString(
1918                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_ADDRESS);
1919                    }
1920    
1921                    return preferences.getValue("emailFromAddress", defaultValue);
1922            }
1923    
1924            @Override
1925            public String getEmailFromName(
1926                            PortletPreferences preferences, long companyId, String defaultValue)
1927                    throws SystemException {
1928    
1929                    if (Validator.isNull(defaultValue)) {
1930                            defaultValue = PrefsPropsUtil.getString(
1931                                    companyId, PropsKeys.ADMIN_EMAIL_FROM_NAME);
1932                    }
1933    
1934                    return preferences.getValue("emailFromName", defaultValue);
1935            }
1936    
1937            @Override
1938            public Map<String, Serializable> getExpandoBridgeAttributes(
1939                            ExpandoBridge expandoBridge, PortletRequest portletRequest)
1940                    throws PortalException, SystemException {
1941    
1942                    Map<String, Serializable> attributes =
1943                            new HashMap<String, Serializable>();
1944    
1945                    List<String> names = new ArrayList<String>();
1946    
1947                    Enumeration<String> enu = portletRequest.getParameterNames();
1948    
1949                    while (enu.hasMoreElements()) {
1950                            String param = enu.nextElement();
1951    
1952                            if (param.contains("ExpandoAttributeName--")) {
1953                                    String name = ParamUtil.getString(portletRequest, param);
1954    
1955                                    names.add(name);
1956                            }
1957                    }
1958    
1959                    for (String name : names) {
1960                            int type = expandoBridge.getAttributeType(name);
1961    
1962                            UnicodeProperties properties = expandoBridge.getAttributeProperties(
1963                                    name);
1964    
1965                            String displayType = GetterUtil.getString(
1966                                    properties.getProperty(
1967                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
1968                                    ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
1969    
1970                            Serializable value = getExpandoValue(
1971                                    portletRequest, "ExpandoAttribute--" + name + "--", type,
1972                                    displayType);
1973    
1974                            attributes.put(name, value);
1975                    }
1976    
1977                    return attributes;
1978            }
1979    
1980            @Override
1981            public Map<String, Serializable> getExpandoBridgeAttributes(
1982                            ExpandoBridge expandoBridge,
1983                            UploadPortletRequest uploadPortletRequest)
1984                    throws PortalException, SystemException {
1985    
1986                    Map<String, Serializable> attributes =
1987                            new HashMap<String, Serializable>();
1988    
1989                    List<String> names = new ArrayList<String>();
1990    
1991                    Enumeration<String> enu = uploadPortletRequest.getParameterNames();
1992    
1993                    while (enu.hasMoreElements()) {
1994                            String param = enu.nextElement();
1995    
1996                            if (param.contains("ExpandoAttributeName--")) {
1997                                    String name = ParamUtil.getString(uploadPortletRequest, param);
1998    
1999                                    names.add(name);
2000                            }
2001                    }
2002    
2003                    for (String name : names) {
2004                            int type = expandoBridge.getAttributeType(name);
2005    
2006                            UnicodeProperties properties = expandoBridge.getAttributeProperties(
2007                                    name);
2008    
2009                            String displayType = GetterUtil.getString(
2010                                    properties.getProperty(
2011                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
2012                                    ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
2013    
2014                            Serializable value = getExpandoValue(
2015                                    uploadPortletRequest, "ExpandoAttribute--" + name + "--", type,
2016                                    displayType);
2017    
2018                            attributes.put(name, value);
2019                    }
2020    
2021                    return attributes;
2022            }
2023    
2024            @Override
2025            public Serializable getExpandoValue(
2026                            PortletRequest portletRequest, String name, int type,
2027                            String displayType)
2028                    throws PortalException, SystemException {
2029    
2030                    Serializable value = null;
2031    
2032                    if (type == ExpandoColumnConstants.BOOLEAN) {
2033                            value = ParamUtil.getBoolean(portletRequest, name);
2034                    }
2035                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2036                    }
2037                    else if (type == ExpandoColumnConstants.DATE) {
2038                            int valueDateMonth = ParamUtil.getInteger(
2039                                    portletRequest, name + "Month");
2040                            int valueDateDay = ParamUtil.getInteger(
2041                                    portletRequest, name + "Day");
2042                            int valueDateYear = ParamUtil.getInteger(
2043                                    portletRequest, name + "Year");
2044                            int valueDateHour = ParamUtil.getInteger(
2045                                    portletRequest, name + "Hour");
2046                            int valueDateMinute = ParamUtil.getInteger(
2047                                    portletRequest, name + "Minute");
2048                            int valueDateAmPm = ParamUtil.getInteger(
2049                                    portletRequest, name + "AmPm");
2050    
2051                            if (valueDateAmPm == Calendar.PM) {
2052                                    valueDateHour += 12;
2053                            }
2054    
2055                            TimeZone timeZone = null;
2056    
2057                            User user = getUser(portletRequest);
2058    
2059                            if (user != null) {
2060                                    timeZone = user.getTimeZone();
2061                            }
2062    
2063                            value = getDate(
2064                                    valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
2065                                    valueDateMinute, timeZone, ValueDataException.class);
2066                    }
2067                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2068                    }
2069                    else if (type == ExpandoColumnConstants.DOUBLE) {
2070                            value = ParamUtil.getDouble(portletRequest, name);
2071                    }
2072                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2073                            String[] values = portletRequest.getParameterValues(name);
2074    
2075                            if (displayType.equals(
2076                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2077    
2078                                    values = StringUtil.splitLines(values[0]);
2079                            }
2080    
2081                            value = GetterUtil.getDoubleValues(values);
2082                    }
2083                    else if (type == ExpandoColumnConstants.FLOAT) {
2084                            value = ParamUtil.getFloat(portletRequest, name);
2085                    }
2086                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2087                            String[] values = portletRequest.getParameterValues(name);
2088    
2089                            if (displayType.equals(
2090                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2091    
2092                                    values = StringUtil.splitLines(values[0]);
2093                            }
2094    
2095                            value = GetterUtil.getFloatValues(values);
2096                    }
2097                    else if (type == ExpandoColumnConstants.INTEGER) {
2098                            value = ParamUtil.getInteger(portletRequest, name);
2099                    }
2100                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2101                            String[] values = portletRequest.getParameterValues(name);
2102    
2103                            if (displayType.equals(
2104                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2105    
2106                                    values = StringUtil.splitLines(values[0]);
2107                            }
2108    
2109                            value = GetterUtil.getIntegerValues(values);
2110                    }
2111                    else if (type == ExpandoColumnConstants.LONG) {
2112                            value = ParamUtil.getLong(portletRequest, name);
2113                    }
2114                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2115                            String[] values = portletRequest.getParameterValues(name);
2116    
2117                            if (displayType.equals(
2118                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2119    
2120                                    values = StringUtil.splitLines(values[0]);
2121                            }
2122    
2123                            value = GetterUtil.getLongValues(values);
2124                    }
2125                    else if (type == ExpandoColumnConstants.NUMBER) {
2126                            value = ParamUtil.getNumber(portletRequest, name);
2127                    }
2128                    else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
2129                            String[] values = portletRequest.getParameterValues(name);
2130    
2131                            if (displayType.equals(
2132                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2133    
2134                                    values = StringUtil.splitLines(values[0]);
2135                            }
2136    
2137                            value = GetterUtil.getNumberValues(values);
2138                    }
2139                    else if (type == ExpandoColumnConstants.SHORT) {
2140                            value = ParamUtil.getShort(portletRequest, name);
2141                    }
2142                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2143                            String[] values = portletRequest.getParameterValues(name);
2144    
2145                            if (displayType.equals(
2146                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2147    
2148                                    values = StringUtil.splitLines(values[0]);
2149                            }
2150    
2151                            value = GetterUtil.getShortValues(values);
2152                    }
2153                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2154                            value = portletRequest.getParameterValues(name);
2155                    }
2156                    else {
2157                            value = ParamUtil.getString(portletRequest, name);
2158                    }
2159    
2160                    return value;
2161            }
2162    
2163            @Override
2164            public Serializable getExpandoValue(
2165                            UploadPortletRequest uploadPortletRequest, String name, int type,
2166                            String displayType)
2167                    throws PortalException, SystemException {
2168    
2169                    Serializable value = null;
2170    
2171                    if (type == ExpandoColumnConstants.BOOLEAN) {
2172                            value = ParamUtil.getBoolean(uploadPortletRequest, name);
2173                    }
2174                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
2175                    }
2176                    else if (type == ExpandoColumnConstants.DATE) {
2177                            int valueDateMonth = ParamUtil.getInteger(
2178                                    uploadPortletRequest, name + "Month");
2179                            int valueDateDay = ParamUtil.getInteger(
2180                                    uploadPortletRequest, name + "Day");
2181                            int valueDateYear = ParamUtil.getInteger(
2182                                    uploadPortletRequest, name + "Year");
2183                            int valueDateHour = ParamUtil.getInteger(
2184                                    uploadPortletRequest, name + "Hour");
2185                            int valueDateMinute = ParamUtil.getInteger(
2186                                    uploadPortletRequest, name + "Minute");
2187                            int valueDateAmPm = ParamUtil.getInteger(
2188                                    uploadPortletRequest, name + "AmPm");
2189    
2190                            if (valueDateAmPm == Calendar.PM) {
2191                                    valueDateHour += 12;
2192                            }
2193    
2194                            TimeZone timeZone = null;
2195    
2196                            User user = getUser(uploadPortletRequest);
2197    
2198                            if (user != null) {
2199                                    timeZone = user.getTimeZone();
2200                            }
2201    
2202                            value = getDate(
2203                                    valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
2204                                    valueDateMinute, timeZone, ValueDataException.class);
2205                    }
2206                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
2207                    }
2208                    else if (type == ExpandoColumnConstants.DOUBLE) {
2209                            value = ParamUtil.getDouble(uploadPortletRequest, name);
2210                    }
2211                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
2212                            String[] values = uploadPortletRequest.getParameterValues(name);
2213    
2214                            if (displayType.equals(
2215                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2216    
2217                                    values = StringUtil.splitLines(values[0]);
2218                            }
2219    
2220                            value = GetterUtil.getDoubleValues(values);
2221                    }
2222                    else if (type == ExpandoColumnConstants.FLOAT) {
2223                            value = ParamUtil.getFloat(uploadPortletRequest, name);
2224                    }
2225                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
2226                            String[] values = uploadPortletRequest.getParameterValues(name);
2227    
2228                            if (displayType.equals(
2229                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2230    
2231                                    values = StringUtil.splitLines(values[0]);
2232                            }
2233    
2234                            value = GetterUtil.getFloatValues(values);
2235                    }
2236                    else if (type == ExpandoColumnConstants.INTEGER) {
2237                            value = ParamUtil.getInteger(uploadPortletRequest, name);
2238                    }
2239                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2240                            String[] values = uploadPortletRequest.getParameterValues(name);
2241    
2242                            if (displayType.equals(
2243                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2244    
2245                                    values = StringUtil.splitLines(values[0]);
2246                            }
2247    
2248                            value = GetterUtil.getIntegerValues(values);
2249                    }
2250                    else if (type == ExpandoColumnConstants.LONG) {
2251                            value = ParamUtil.getLong(uploadPortletRequest, name);
2252                    }
2253                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2254                            String[] values = uploadPortletRequest.getParameterValues(name);
2255    
2256                            if (displayType.equals(
2257                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2258    
2259                                    values = StringUtil.splitLines(values[0]);
2260                            }
2261    
2262                            value = GetterUtil.getLongValues(values);
2263                    }
2264                    else if (type == ExpandoColumnConstants.SHORT) {
2265                            value = ParamUtil.getShort(uploadPortletRequest, name);
2266                    }
2267                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2268                            String[] values = uploadPortletRequest.getParameterValues(name);
2269    
2270                            if (displayType.equals(
2271                                            ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2272    
2273                                    values = StringUtil.splitLines(values[0]);
2274                            }
2275    
2276                            value = GetterUtil.getShortValues(values);
2277                    }
2278                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2279                            value = uploadPortletRequest.getParameterValues(name);
2280                    }
2281                    else {
2282                            value = ParamUtil.getString(uploadPortletRequest, name);
2283                    }
2284    
2285                    return value;
2286            }
2287    
2288            @Override
2289            public String getFacebookURL(
2290                            Portlet portlet, String facebookCanvasPageURL,
2291                            ThemeDisplay themeDisplay)
2292                    throws PortalException, SystemException {
2293    
2294                    String facebookURL = getServletURL(
2295                            portlet, FacebookUtil.FACEBOOK_SERVLET_PATH + facebookCanvasPageURL,
2296                            themeDisplay);
2297    
2298                    if (!facebookURL.endsWith(StringPool.SLASH)) {
2299                            facebookURL += StringPool.SLASH;
2300                    }
2301    
2302                    return facebookURL;
2303            }
2304    
2305            @Override
2306            public Portlet getFirstMyAccountPortlet(ThemeDisplay themeDisplay)
2307                    throws SystemException {
2308    
2309                    List<Portlet> portlets = getControlPanelPortlets(
2310                            PortletCategoryKeys.MY, themeDisplay);
2311    
2312                    if (portlets.isEmpty()) {
2313                            return null;
2314                    }
2315    
2316                    return portlets.get(0);
2317            }
2318    
2319            @Override
2320            public String getFirstPageLayoutTypes(PageContext pageContext) {
2321                    StringBundler sb = new StringBundler();
2322    
2323                    for (String type : PropsValues.LAYOUT_TYPES) {
2324                            if (isLayoutFirstPageable(type)) {
2325                                    sb.append(
2326                                            LanguageUtil.get(pageContext, "layout.types." + type));
2327                                    sb.append(StringPool.COMMA);
2328                                    sb.append(StringPool.SPACE);
2329                            }
2330                    }
2331    
2332                    if (sb.index() >= 2) {
2333                            sb.setIndex(sb.index() - 2);
2334                    }
2335    
2336                    return sb.toString();
2337            }
2338    
2339            @Override
2340            public Portlet getFirstSiteAdministrationPortlet(ThemeDisplay themeDisplay)
2341                    throws SystemException {
2342    
2343                    Portlet siteAdministrationPortlet = null;
2344    
2345                    for (String category : PortletCategoryKeys.SITE_ADMINISTRATION_ALL) {
2346                            List<Portlet> portlets = getControlPanelPortlets(
2347                                    category, themeDisplay);
2348    
2349                            if (portlets.isEmpty()) {
2350                                    continue;
2351                            }
2352    
2353                            return portlets.get(0);
2354                    }
2355    
2356                    return siteAdministrationPortlet;
2357            }
2358    
2359            @Override
2360            public String getFullName(
2361                    String firstName, String middleName, String lastName) {
2362    
2363                    FullNameGenerator fullNameGenerator =
2364                            FullNameGeneratorFactory.getInstance();
2365    
2366                    return fullNameGenerator.getFullName(firstName, middleName, lastName);
2367            }
2368    
2369            @Override
2370            public String getGlobalLibDir() {
2371                    return PropsValues.LIFERAY_LIB_GLOBAL_DIR;
2372            }
2373    
2374            @Override
2375            public String getGoogleGadgetURL(Portlet portlet, ThemeDisplay themeDisplay)
2376                    throws PortalException, SystemException {
2377    
2378                    return getServletURL(
2379                            portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
2380            }
2381    
2382            @Override
2383            public String getGroupFriendlyURL(
2384                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay)
2385                    throws PortalException, SystemException {
2386    
2387                    return getGroupFriendlyURL(
2388                            group, privateLayoutSet, themeDisplay, false);
2389            }
2390    
2391            @Override
2392            public String getGroupFriendlyURL(
2393                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
2394                            Locale locale)
2395                    throws PortalException, SystemException {
2396    
2397                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
2398                    String i18nPath = themeDisplay.getI18nPath();
2399    
2400                    try {
2401                            setThemeDisplayI18n(themeDisplay, locale);
2402    
2403                            return getGroupFriendlyURL(group, privateLayoutSet, themeDisplay);
2404                    }
2405                    finally {
2406                            resetThemeDisplayI18n(themeDisplay, i18nLanguageId, i18nPath);
2407                    }
2408            }
2409    
2410            @Override
2411            public int[] getGroupFriendlyURLIndex(String requestURI) {
2412                    int x = 0;
2413                    int y = 0;
2414    
2415                    if (requestURI.startsWith(_PRIVATE_GROUP_SERVLET_MAPPING) ||
2416                            requestURI.startsWith(_PRIVATE_USER_SERVLET_MAPPING) ||
2417                            requestURI.startsWith(_PUBLIC_GROUP_SERVLET_MAPPING)) {
2418    
2419                            x = requestURI.indexOf(StringPool.SLASH, 1);
2420    
2421                            if (x == -1) {
2422    
2423                                    // /web
2424    
2425                                    requestURI += StringPool.SLASH;
2426    
2427                                    x = requestURI.indexOf(CharPool.SLASH, 1);
2428                            }
2429    
2430                            y = requestURI.indexOf(CharPool.SLASH, x + 1);
2431    
2432                            if (y == -1) {
2433    
2434                                    // /web/alpha
2435    
2436                                    requestURI += StringPool.SLASH;
2437    
2438                                    y = requestURI.indexOf(CharPool.SLASH, x + 1);
2439                            }
2440    
2441                            return new int[] {x, y};
2442                    }
2443    
2444                    return null;
2445            }
2446    
2447            @Override
2448            public String[] getGroupPermissions(HttpServletRequest request) {
2449                    return request.getParameterValues("groupPermissions");
2450            }
2451    
2452            @Override
2453            public String[] getGroupPermissions(
2454                    HttpServletRequest request, String className) {
2455    
2456                    return request.getParameterValues("groupPermissions_" + className);
2457            }
2458    
2459            @Override
2460            public String[] getGroupPermissions(PortletRequest portletRequest) {
2461                    return portletRequest.getParameterValues("groupPermissions");
2462            }
2463    
2464            @Override
2465            public String[] getGroupPermissions(
2466                    PortletRequest portletRequest, String className) {
2467    
2468                    return portletRequest.getParameterValues(
2469                            "groupPermissions_" + className);
2470            }
2471    
2472            @Override
2473            public String[] getGuestPermissions(HttpServletRequest request) {
2474                    return request.getParameterValues("guestPermissions");
2475            }
2476    
2477            @Override
2478            public String[] getGuestPermissions(
2479                    HttpServletRequest request, String className) {
2480    
2481                    return request.getParameterValues("guestPermissions_" + className);
2482            }
2483    
2484            @Override
2485            public String[] getGuestPermissions(PortletRequest portletRequest) {
2486                    return portletRequest.getParameterValues("guestPermissions");
2487            }
2488    
2489            @Override
2490            public String[] getGuestPermissions(
2491                    PortletRequest portletRequest, String className) {
2492    
2493                    return portletRequest.getParameterValues(
2494                            "guestPermissions_" + className);
2495            }
2496    
2497            @Override
2498            public String getHomeURL(HttpServletRequest request)
2499                    throws PortalException, SystemException {
2500    
2501                    String portalURL = getPortalURL(request);
2502    
2503                    return portalURL + _pathContext + getRelativeHomeURL(request);
2504            }
2505    
2506            @Override
2507            public String getHost(HttpServletRequest request) {
2508                    request = getOriginalServletRequest(request);
2509    
2510                    String host = request.getHeader("Host");
2511    
2512                    if (host != null) {
2513                            host = host.trim().toLowerCase();
2514    
2515                            int pos = host.indexOf(':');
2516    
2517                            if (pos >= 0) {
2518                                    host = host.substring(0, pos);
2519                            }
2520                    }
2521                    else {
2522                            host = null;
2523                    }
2524    
2525                    return host;
2526            }
2527    
2528            @Override
2529            public String getHost(PortletRequest portletRequest) {
2530                    return getHost(getHttpServletRequest(portletRequest));
2531            }
2532    
2533            @Override
2534            public HttpServletRequest getHttpServletRequest(
2535                    PortletRequest portletRequest) {
2536    
2537                    PortletRequestImpl portletRequestImpl =
2538                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
2539    
2540                    return portletRequestImpl.getHttpServletRequest();
2541            }
2542    
2543            @Override
2544            public HttpServletResponse getHttpServletResponse(
2545                    PortletResponse portletResponse) {
2546    
2547                    PortletResponseImpl portletResponseImpl =
2548                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
2549    
2550                    return portletResponseImpl.getHttpServletResponse();
2551            }
2552    
2553            @Override
2554            public String getI18nPathLanguageId(
2555                    Locale locale, String defaultI18nPathLanguageId) {
2556    
2557                    String i18nPathLanguageId = defaultI18nPathLanguageId;
2558    
2559                    if (!LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
2560                            i18nPathLanguageId = locale.getLanguage();
2561                    }
2562                    else {
2563                            Locale priorityLocale = LanguageUtil.getLocale(
2564                                    locale.getLanguage());
2565    
2566                            if (locale.equals(priorityLocale)) {
2567                                    i18nPathLanguageId = locale.getLanguage();
2568                            }
2569                    }
2570    
2571                    return i18nPathLanguageId;
2572            }
2573    
2574            @Override
2575            public String getJournalArticleActualURL(
2576                            long groupId, boolean privateLayout, String mainPath,
2577                            String friendlyURL, Map<String, String[]> params,
2578                            Map<String, Object> requestContext)
2579                    throws PortalException, SystemException {
2580    
2581                    String urlTitle = friendlyURL.substring(
2582                            JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
2583    
2584                    JournalArticle journalArticle =
2585                            JournalArticleLocalServiceUtil.getArticleByUrlTitle(
2586                                    groupId, urlTitle);
2587    
2588                    Layout layout = getJournalArticleLayout(
2589                            groupId, privateLayout, friendlyURL);
2590    
2591                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
2592    
2593                    InheritableMap<String, String[]> actualParams =
2594                            new InheritableMap<String, String[]>();
2595    
2596                    if (params != null) {
2597                            actualParams.setParentMap(params);
2598                    }
2599    
2600                    UnicodeProperties typeSettingsProperties =
2601                            layout.getTypeSettingsProperties();
2602    
2603                    String defaultAssetPublisherPortletId = typeSettingsProperties.get(
2604                            LayoutTypePortletConstants.DEFAULT_ASSET_PUBLISHER_PORTLET_ID);
2605    
2606                    String currentDefaultAssetPublisherPortletId =
2607                            defaultAssetPublisherPortletId;
2608    
2609                    if (Validator.isNull(defaultAssetPublisherPortletId)) {
2610                            String instanceId = LayoutTypePortletImpl.generateInstanceId();
2611    
2612                            defaultAssetPublisherPortletId = PortletConstants.assemblePortletId(
2613                                    PortletKeys.ASSET_PUBLISHER, instanceId);
2614                    }
2615    
2616                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
2617                            "request");
2618    
2619                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2620                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
2621                                    request, layout.getPlid(), defaultAssetPublisherPortletId);
2622    
2623                            actualParams.put(
2624                                    "p_p_auth", new String[] {actualPortletAuthenticationToken});
2625                    }
2626    
2627                    actualParams.put(
2628                            "p_p_id", new String[] {defaultAssetPublisherPortletId});
2629                    actualParams.put("p_p_lifecycle", new String[] {"0"});
2630    
2631                    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2632                            actualParams.put(
2633                                    "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
2634                    }
2635    
2636                    actualParams.put("p_p_mode", new String[] {"view"});
2637                    actualParams.put(
2638                            "p_j_a_id", new String[] {String.valueOf(journalArticle.getId())});
2639    
2640                    String namespace = getPortletNamespace(defaultAssetPublisherPortletId);
2641    
2642                    actualParams.put(
2643                            namespace + "struts_action",
2644                            new String[] {"/asset_publisher/view_content"});
2645                    actualParams.put(
2646                            namespace + "type",
2647                            new String[] {JournalArticleAssetRendererFactory.TYPE});
2648                    actualParams.put(
2649                            namespace + "urlTitle",
2650                            new String[] {journalArticle.getUrlTitle()});
2651    
2652                    String queryString = HttpUtil.parameterMapToString(actualParams, false);
2653    
2654                    if (layoutActualURL.contains(StringPool.QUESTION)) {
2655                            layoutActualURL =
2656                                    layoutActualURL + StringPool.AMPERSAND + queryString;
2657                    }
2658                    else {
2659                            layoutActualURL =
2660                                    layoutActualURL + StringPool.QUESTION + queryString;
2661                    }
2662    
2663                    Locale locale = getLocale(request);
2664    
2665                    addPageSubtitle(journalArticle.getTitle(locale), request);
2666                    addPageDescription(journalArticle.getDescription(locale), request);
2667    
2668                    List<AssetTag> assetTags = AssetTagLocalServiceUtil.getTags(
2669                            JournalArticle.class.getName(), journalArticle.getPrimaryKey());
2670    
2671                    if (!assetTags.isEmpty()) {
2672                            addPageKeywords(
2673                                    ListUtil.toString(assetTags, AssetTag.NAME_ACCESSOR), request);
2674                    }
2675    
2676                    return layoutActualURL;
2677            }
2678    
2679            @Override
2680            public Layout getJournalArticleLayout(
2681                            long groupId, boolean privateLayout, String friendlyURL)
2682                    throws PortalException, SystemException {
2683    
2684                    String urlTitle = friendlyURL.substring(
2685                            JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
2686    
2687                    JournalArticle journalArticle =
2688                            JournalArticleLocalServiceUtil.getArticleByUrlTitle(
2689                                    groupId, urlTitle);
2690    
2691                    return LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
2692                            journalArticle.getLayoutUuid(), groupId, privateLayout);
2693            }
2694    
2695            @Override
2696            public String getJsSafePortletId(String portletId) {
2697                    return JS.getSafeName(portletId);
2698            }
2699    
2700            @Override
2701            public String getLayoutActualURL(Layout layout) {
2702                    return getLayoutActualURL(layout, getPathMain());
2703            }
2704    
2705            @Override
2706            public String getLayoutActualURL(Layout layout, String mainPath) {
2707                    Map<String, String> variables = new HashMap<String, String>();
2708    
2709                    variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
2710                    variables.put("liferay:mainPath", mainPath);
2711                    variables.put("liferay:plid", String.valueOf(layout.getPlid()));
2712    
2713                    if (layout instanceof VirtualLayout) {
2714                            variables.put(
2715                                    "liferay:pvlsgid", String.valueOf(layout.getGroupId()));
2716                    }
2717                    else {
2718                            variables.put("liferay:pvlsgid", "0");
2719                    }
2720    
2721                    LayoutType layoutType = layout.getLayoutType();
2722    
2723                    UnicodeProperties typeSettingsProperties =
2724                            layoutType.getTypeSettingsProperties();
2725    
2726                    variables.putAll(typeSettingsProperties);
2727    
2728                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
2729    
2730                    return layoutSettings.getURL(variables);
2731            }
2732    
2733            @Override
2734            public String getLayoutActualURL(
2735                            long groupId, boolean privateLayout, String mainPath,
2736                            String friendlyURL)
2737                    throws PortalException, SystemException {
2738    
2739                    return getLayoutActualURL(
2740                            groupId, privateLayout, mainPath, friendlyURL, null, null);
2741            }
2742    
2743            @Override
2744            public String getLayoutActualURL(
2745                            long groupId, boolean privateLayout, String mainPath,
2746                            String friendlyURL, Map<String, String[]> params,
2747                            Map<String, Object> requestContext)
2748                    throws PortalException, SystemException {
2749    
2750                    LayoutQueryStringComposite actualLayoutQueryStringComposite =
2751                            getActualLayoutQueryStringComposite(
2752                                    groupId, privateLayout, friendlyURL, params, requestContext);
2753    
2754                    Layout layout = actualLayoutQueryStringComposite.getLayout();
2755                    String queryString = actualLayoutQueryStringComposite.getQueryString();
2756    
2757                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
2758    
2759                    if (Validator.isNotNull(queryString)) {
2760                            layoutActualURL = layoutActualURL.concat(queryString);
2761                    }
2762                    else if (params.isEmpty()) {
2763                            LayoutType layoutType = layout.getLayoutType();
2764    
2765                            UnicodeProperties typeSettingsProperties =
2766                                    layoutType.getTypeSettingsProperties();
2767    
2768                            queryString = typeSettingsProperties.getProperty("query-string");
2769    
2770                            if (Validator.isNotNull(queryString) &&
2771                                    layoutActualURL.contains(StringPool.QUESTION)) {
2772    
2773                                    layoutActualURL = layoutActualURL.concat(
2774                                            StringPool.AMPERSAND).concat(queryString);
2775                            }
2776                    }
2777    
2778                    return layoutActualURL;
2779            }
2780    
2781            @Override
2782            public String getLayoutEditPage(Layout layout) {
2783                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
2784                            layout.getType());
2785    
2786                    return layoutSettings.getEditPage();
2787            }
2788    
2789            @Override
2790            public String getLayoutEditPage(String type) {
2791                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2792    
2793                    return layoutSettings.getEditPage();
2794            }
2795    
2796            @Override
2797            public String getLayoutFriendlyURL(Layout layout, ThemeDisplay themeDisplay)
2798                    throws PortalException, SystemException {
2799    
2800                    if (!isLayoutFriendliable(layout)) {
2801                            return null;
2802                    }
2803    
2804                    String groupFriendlyURL = getGroupFriendlyURL(
2805                            layout.getGroup(), layout.isPrivateLayout(), themeDisplay);
2806    
2807                    return groupFriendlyURL.concat(
2808                            layout.getFriendlyURL(themeDisplay.getLocale()));
2809            }
2810    
2811            @Override
2812            public String getLayoutFriendlyURL(
2813                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
2814                    throws PortalException, SystemException {
2815    
2816                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
2817                    String i18nPath = themeDisplay.getI18nPath();
2818    
2819                    try {
2820                            setThemeDisplayI18n(themeDisplay, locale);
2821    
2822                            return getLayoutFriendlyURL(layout, themeDisplay);
2823                    }
2824                    finally {
2825                            resetThemeDisplayI18n(themeDisplay, i18nLanguageId, i18nPath);
2826                    }
2827            }
2828    
2829            @Override
2830            public LayoutFriendlyURLComposite getLayoutFriendlyURLComposite(
2831                            long groupId, boolean privateLayout, String friendlyURL,
2832                            Map<String, String[]> params, Map<String, Object> requestContext)
2833                    throws PortalException, SystemException {
2834    
2835                    Layout layout = null;
2836                    String layoutFriendlyURL = friendlyURL;
2837    
2838                    if (friendlyURL != null) {
2839                            if (friendlyURL.startsWith(
2840                                            JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
2841    
2842                                    try {
2843                                            layout = getJournalArticleLayout(
2844                                                    groupId, privateLayout, friendlyURL);
2845                                    }
2846                                    catch (Exception e) {
2847                                            throw new NoSuchLayoutException(e);
2848                                    }
2849                            }
2850                            else if (friendlyURL.startsWith(
2851                                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
2852    
2853                                    try {
2854                                            LayoutFriendlyURLComposite layoutFriendlyURLComposite =
2855                                                    getVirtualLayoutFriendlyURLComposite(
2856                                                            privateLayout, friendlyURL, params, requestContext);
2857    
2858                                            layout = layoutFriendlyURLComposite.getLayout();
2859                                            layoutFriendlyURL =
2860                                                    layoutFriendlyURLComposite.getFriendlyURL();
2861                                    }
2862                                    catch (Exception e) {
2863                                            throw new NoSuchLayoutException(e);
2864                                    }
2865                            }
2866                    }
2867    
2868                    if (layout == null) {
2869                            LayoutQueryStringComposite layoutQueryStringComposite =
2870                                    getActualLayoutQueryStringComposite(
2871                                            groupId, privateLayout, friendlyURL, params,
2872                                            requestContext);
2873    
2874                            layout = layoutQueryStringComposite.getLayout();
2875                    }
2876    
2877                    return new LayoutFriendlyURLComposite(layout, layoutFriendlyURL);
2878            }
2879    
2880            @Override
2881            public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
2882                    throws PortalException, SystemException {
2883    
2884                    return getLayoutFullURL(layout, themeDisplay, true);
2885            }
2886    
2887            @Override
2888            public String getLayoutFullURL(
2889                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2890                    throws PortalException, SystemException {
2891    
2892                    String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
2893                    String portalURL = getPortalURL(layout, themeDisplay);
2894    
2895                    if (StringUtil.startsWith(layoutURL, portalURL)) {
2896                            return layoutURL;
2897                    }
2898                    else {
2899                            return portalURL + layoutURL;
2900                    }
2901            }
2902    
2903            @Override
2904            public String getLayoutFullURL(long groupId, String portletId)
2905                    throws PortalException, SystemException {
2906    
2907                    return getLayoutFullURL(groupId, portletId, false);
2908            }
2909    
2910            @Override
2911            public String getLayoutFullURL(
2912                            long groupId, String portletId, boolean secure)
2913                    throws PortalException, SystemException {
2914    
2915                    long plid = getPlidFromPortletId(groupId, portletId);
2916    
2917                    if (plid == LayoutConstants.DEFAULT_PLID) {
2918                            return null;
2919                    }
2920    
2921                    StringBundler sb = new StringBundler(4);
2922    
2923                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2924    
2925                    Group group = GroupLocalServiceUtil.getGroup(groupId);
2926    
2927                    if (group.isLayout()) {
2928                            long parentGroupId = group.getParentGroupId();
2929    
2930                            if (parentGroupId > 0) {
2931                                    group = GroupLocalServiceUtil.getGroup(parentGroupId);
2932                            }
2933                    }
2934    
2935                    String virtualHostname = null;
2936    
2937                    LayoutSet layoutSet = layout.getLayoutSet();
2938    
2939                    if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
2940                            virtualHostname = layoutSet.getVirtualHostname();
2941                    }
2942                    else {
2943                            Company company = CompanyLocalServiceUtil.getCompany(
2944                                    layout.getCompanyId());
2945    
2946                            virtualHostname = company.getVirtualHostname();
2947                    }
2948    
2949                    String portalURL = getPortalURL(
2950                            virtualHostname, getPortalPort(secure), secure);
2951    
2952                    sb.append(portalURL);
2953    
2954                    if (layout.isPrivateLayout()) {
2955                            if (group.isUser()) {
2956                                    sb.append(getPathFriendlyURLPrivateUser());
2957                            }
2958                            else {
2959                                    sb.append(getPathFriendlyURLPrivateGroup());
2960                            }
2961                    }
2962                    else {
2963                            sb.append(getPathFriendlyURLPublic());
2964                    }
2965    
2966                    sb.append(group.getFriendlyURL());
2967                    sb.append(layout.getFriendlyURL());
2968    
2969                    return sb.toString();
2970            }
2971    
2972            @Override
2973            public String getLayoutFullURL(ThemeDisplay themeDisplay)
2974                    throws PortalException, SystemException {
2975    
2976                    return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
2977            }
2978    
2979            @Override
2980            public String getLayoutSetFriendlyURL(
2981                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
2982                    throws PortalException, SystemException {
2983    
2984                    String virtualHostname = layoutSet.getVirtualHostname();
2985    
2986                    if (Validator.isNull(virtualHostname) &&
2987                            Validator.isNotNull(PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
2988                            !layoutSet.isPrivateLayout()) {
2989    
2990                            try {
2991                                    Group group = GroupLocalServiceUtil.getGroup(
2992                                            themeDisplay.getCompanyId(),
2993                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
2994    
2995                                    if (layoutSet.getGroupId() == group.getGroupId()) {
2996                                            Company company = themeDisplay.getCompany();
2997    
2998                                            virtualHostname = company.getVirtualHostname();
2999                                    }
3000                            }
3001                            catch (Exception e) {
3002                                    _log.error(e, e);
3003                            }
3004                    }
3005    
3006                    if (Validator.isNotNull(virtualHostname)) {
3007                            String portalURL = getPortalURL(
3008                                    virtualHostname, themeDisplay.getServerPort(),
3009                                    themeDisplay.isSecure());
3010    
3011                            // Use the layout set's virtual host setting only if the layout set
3012                            // is already used for the current request
3013    
3014                            long curLayoutSetId =
3015                                    themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
3016    
3017                            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
3018                                    portalURL.startsWith(themeDisplay.getURLPortal())) {
3019    
3020                                    String layoutSetFriendlyURL = StringPool.BLANK;
3021    
3022                                    if (themeDisplay.isI18n()) {
3023                                            layoutSetFriendlyURL = themeDisplay.getI18nPath();
3024                                    }
3025    
3026                                    return portalURL + _pathContext + layoutSetFriendlyURL;
3027                            }
3028                    }
3029    
3030                    Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
3031    
3032                    String friendlyURL = null;
3033    
3034                    if (layoutSet.isPrivateLayout()) {
3035                            if (group.isUser()) {
3036                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
3037                            }
3038                            else {
3039                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
3040                            }
3041                    }
3042                    else {
3043                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
3044                    }
3045    
3046                    if (themeDisplay.isI18n()) {
3047                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
3048                    }
3049    
3050                    String layoutSetFriendlyURL =
3051                            _pathContext + friendlyURL + group.getFriendlyURL();
3052    
3053                    return addPreservedParameters(themeDisplay, layoutSetFriendlyURL);
3054            }
3055    
3056            @Override
3057            public String getLayoutTarget(Layout layout) {
3058                    UnicodeProperties typeSettingsProps =
3059                            layout.getTypeSettingsProperties();
3060    
3061                    String target = typeSettingsProps.getProperty("target");
3062    
3063                    if (Validator.isNull(target)) {
3064                            target = StringPool.BLANK;
3065                    }
3066                    else {
3067                            target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
3068                    }
3069    
3070                    return target;
3071            }
3072    
3073            @Override
3074            public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
3075                    throws PortalException, SystemException {
3076    
3077                    return getLayoutURL(layout, themeDisplay, true);
3078            }
3079    
3080            @Override
3081            public String getLayoutURL(
3082                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
3083                    throws PortalException, SystemException {
3084    
3085                    if (layout == null) {
3086                            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
3087                    }
3088    
3089                    if (!layout.isTypeURL()) {
3090                            String layoutFriendlyURL = getLayoutFriendlyURL(
3091                                    layout, themeDisplay);
3092    
3093                            if (Validator.isNotNull(layoutFriendlyURL)) {
3094                                    layoutFriendlyURL = addPreservedParameters(
3095                                            themeDisplay, layout, layoutFriendlyURL, doAsUser);
3096    
3097                                    return layoutFriendlyURL;
3098                            }
3099                    }
3100    
3101                    String layoutURL = getLayoutActualURL(layout);
3102    
3103                    layoutURL = addPreservedParameters(
3104                            themeDisplay, layout, layoutURL, doAsUser);
3105    
3106                    return layoutURL;
3107            }
3108    
3109            @Override
3110            public String getLayoutURL(ThemeDisplay themeDisplay)
3111                    throws PortalException, SystemException {
3112    
3113                    return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
3114            }
3115    
3116            @Override
3117            public String getLayoutViewPage(Layout layout) {
3118                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
3119                            layout.getType());
3120    
3121                    return layoutSettings.getViewPage();
3122            }
3123    
3124            @Override
3125            public String getLayoutViewPage(String type) {
3126                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3127    
3128                    return layoutSettings.getViewPage();
3129            }
3130    
3131            @Override
3132            public LiferayPortletRequest getLiferayPortletRequest(
3133                    PortletRequest portletRequest) {
3134    
3135                    PortletRequestImpl portletRequestImpl =
3136                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
3137    
3138                    return DoPrivilegedUtil.wrapWhenActive(portletRequestImpl);
3139            }
3140    
3141            @Override
3142            public LiferayPortletResponse getLiferayPortletResponse(
3143                    PortletResponse portletResponse) {
3144    
3145                    PortletResponseImpl portletResponseImpl =
3146                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
3147    
3148                    return DoPrivilegedUtil.wrapWhenActive(portletResponseImpl);
3149            }
3150    
3151            @Override
3152            public Locale getLocale(HttpServletRequest request) {
3153                    return getLocale(request, null, false);
3154            }
3155    
3156            @Override
3157            public Locale getLocale(
3158                    HttpServletRequest request, HttpServletResponse response,
3159                    boolean initialize) {
3160    
3161                    User user = null;
3162    
3163                    if (initialize) {
3164                            try {
3165                                    user = initUser(request);
3166                            }
3167                            catch (NoSuchUserException nsue) {
3168                                    return null;
3169                            }
3170                            catch (Exception e) {
3171                            }
3172                    }
3173    
3174                    Locale locale = null;
3175    
3176                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3177                            WebKeys.THEME_DISPLAY);
3178    
3179                    if (themeDisplay != null) {
3180                            locale = themeDisplay.getLocale();
3181    
3182                            if (LanguageUtil.isAvailableLocale(
3183                                            themeDisplay.getSiteGroupId(), locale)) {
3184    
3185                                    return locale;
3186                            }
3187                    }
3188    
3189                    long groupId = 0;
3190    
3191                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3192    
3193                    if ((layout != null) && !layout.isTypeControlPanel()) {
3194                            try {
3195                                    long scopeGroupId = getScopeGroupId(request);
3196    
3197                                    groupId = getSiteGroupId(scopeGroupId);
3198                            }
3199                            catch (Exception e) {
3200                            }
3201                    }
3202    
3203                    String i18nLanguageId = (String)request.getAttribute(
3204                            WebKeys.I18N_LANGUAGE_ID);
3205    
3206                    if (Validator.isNotNull(i18nLanguageId)) {
3207                            locale = LocaleUtil.fromLanguageId(i18nLanguageId);
3208    
3209                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3210                                    return locale;
3211                            }
3212                    }
3213    
3214                    String doAsUserLanguageId = ParamUtil.getString(
3215                            request, "doAsUserLanguageId");
3216    
3217                    if (Validator.isNotNull(doAsUserLanguageId)) {
3218                            locale = LocaleUtil.fromLanguageId(doAsUserLanguageId);
3219    
3220                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3221                                    return locale;
3222                            }
3223                    }
3224    
3225                    HttpSession session = request.getSession();
3226    
3227                    if (session.getAttribute(Globals.LOCALE_KEY) != null) {
3228                            locale = (Locale)session.getAttribute(Globals.LOCALE_KEY);
3229    
3230                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3231                                    return locale;
3232                            }
3233                    }
3234    
3235                    // Get locale from the user
3236    
3237                    if (user == null) {
3238                            try {
3239                                    user = getUser(request);
3240                            }
3241                            catch (Exception e) {
3242                            }
3243                    }
3244    
3245                    if ((user != null) && !user.isDefaultUser()) {
3246                            Locale userLocale = getAvailableLocale(groupId, user.getLocale());
3247    
3248                            if (userLocale != null) {
3249                                    if (LanguageUtil.isAvailableLocale(groupId, userLocale)) {
3250                                            if (initialize) {
3251                                                    setLocale(request, response, userLocale);
3252                                            }
3253    
3254                                            return userLocale;
3255                                    }
3256                            }
3257                    }
3258    
3259                    // Get locale from the cookie
3260    
3261                    String languageId = CookieKeys.getCookie(
3262                            request, CookieKeys.GUEST_LANGUAGE_ID, false);
3263    
3264                    if (Validator.isNotNull(languageId)) {
3265                            Locale cookieLocale = getAvailableLocale(
3266                                    groupId, LocaleUtil.fromLanguageId(languageId));
3267    
3268                            if (cookieLocale != null) {
3269                                    if (LanguageUtil.isAvailableLocale(groupId, cookieLocale)) {
3270                                            if (initialize) {
3271                                                    setLocale(request, response, cookieLocale);
3272                                            }
3273    
3274                                            return cookieLocale;
3275                                    }
3276                            }
3277                    }
3278    
3279                    // Get locale from the request
3280    
3281                    if (PropsValues.LOCALE_DEFAULT_REQUEST) {
3282                            Enumeration<Locale> locales = request.getLocales();
3283    
3284                            while (locales.hasMoreElements()) {
3285                                    Locale requestLocale = getAvailableLocale(
3286                                            groupId, locales.nextElement());
3287    
3288                                    if (requestLocale != null) {
3289                                            if (LanguageUtil.isAvailableLocale(
3290                                                            groupId, requestLocale)) {
3291    
3292                                                    if (initialize) {
3293                                                            setLocale(request, response, requestLocale);
3294                                                    }
3295    
3296                                                    return requestLocale;
3297                                            }
3298                                    }
3299                            }
3300                    }
3301    
3302                    // Get locale from the default user
3303    
3304                    Company company = null;
3305    
3306                    try {
3307                            company = getCompany(request);
3308                    }
3309                    catch (Exception e) {
3310                    }
3311    
3312                    if (company == null) {
3313                            return null;
3314                    }
3315    
3316                    User defaultUser = null;
3317    
3318                    try {
3319                            defaultUser = company.getDefaultUser();
3320                    }
3321                    catch (Exception e) {
3322                    }
3323    
3324                    if (defaultUser == null) {
3325                            return null;
3326                    }
3327    
3328                    Locale defaultUserLocale = getAvailableLocale(
3329                            groupId, defaultUser.getLocale());
3330    
3331                    if (defaultUserLocale != null) {
3332                            if (LanguageUtil.isAvailableLocale(groupId, defaultUserLocale)) {
3333                                    if (initialize) {
3334                                            setLocale(request, response, defaultUserLocale);
3335                                    }
3336    
3337                                    return defaultUserLocale;
3338                            }
3339                    }
3340    
3341                    try {
3342                            if (themeDisplay != null) {
3343                                    return themeDisplay.getSiteDefaultLocale();
3344                            }
3345                    }
3346                    catch (Exception e) {
3347                    }
3348    
3349                    try {
3350                            return getSiteDefaultLocale(groupId);
3351                    }
3352                    catch (Exception e) {
3353                            return LocaleUtil.getDefault();
3354                    }
3355            }
3356    
3357            @Override
3358            public Locale getLocale(RenderRequest renderRequest) {
3359                    return getLocale(getHttpServletRequest(renderRequest));
3360            }
3361    
3362            @Override
3363            public String getLocalizedFriendlyURL(
3364                            HttpServletRequest request, Layout layout, Locale locale)
3365                    throws Exception {
3366    
3367                    String contextPath = getPathContext();
3368    
3369                    String requestURI = request.getRequestURI();
3370    
3371                    if (Validator.isNotNull(contextPath) &&
3372                            requestURI.contains(contextPath)) {
3373    
3374                            requestURI = requestURI.substring(contextPath.length());
3375                    }
3376    
3377                    requestURI = StringUtil.replace(
3378                            requestURI, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3379    
3380                    String path = request.getPathInfo();
3381    
3382                    int x = path.indexOf(CharPool.SLASH, 1);
3383    
3384                    String layoutFriendlyURL = null;
3385    
3386                    if ((x != -1) && ((x + 1) != path.length())) {
3387                            layoutFriendlyURL = path.substring(x);
3388                    }
3389    
3390                    int y = layoutFriendlyURL.indexOf(
3391                            VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
3392    
3393                    if (y != -1) {
3394                            y = layoutFriendlyURL.indexOf(CharPool.SLASH, 3);
3395    
3396                            if ((y != -1) && ((y + 1) != layoutFriendlyURL.length())) {
3397                                    layoutFriendlyURL = layoutFriendlyURL.substring(y);
3398                            }
3399                    }
3400    
3401                    y = layoutFriendlyURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
3402    
3403                    if (y != -1) {
3404                            layoutFriendlyURL = layoutFriendlyURL.substring(0, y);
3405                    }
3406    
3407                    if (requestURI.contains(layoutFriendlyURL)) {
3408                            requestURI = StringUtil.replaceFirst(
3409                                    requestURI, layoutFriendlyURL, layout.getFriendlyURL(locale));
3410                    }
3411    
3412                    String i18nPath = getI18nPathLanguageId(
3413                            locale, LocaleUtil.toLanguageId(locale));
3414    
3415                    String localizedFriendlyURL =
3416                            contextPath + StringPool.SLASH + i18nPath + requestURI;
3417    
3418                    String queryString = request.getQueryString();
3419    
3420                    if (Validator.isNotNull(queryString)) {
3421                            localizedFriendlyURL +=
3422                                    StringPool.QUESTION + request.getQueryString();
3423                    }
3424    
3425                    return localizedFriendlyURL;
3426            }
3427    
3428            @Override
3429            public String getMailId(String mx, String popPortletPrefix, Object... ids) {
3430                    StringBundler sb = new StringBundler(ids.length * 2 + 7);
3431    
3432                    sb.append(StringPool.LESS_THAN);
3433                    sb.append(popPortletPrefix);
3434    
3435                    if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
3436                            sb.append(StringPool.PERIOD);
3437                    }
3438    
3439                    for (int i = 0; i < ids.length; i++) {
3440                            Object id = ids[i];
3441    
3442                            if (i != 0) {
3443                                    sb.append(StringPool.PERIOD);
3444                            }
3445    
3446                            sb.append(id);
3447                    }
3448    
3449                    sb.append(StringPool.AT);
3450    
3451                    if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
3452                            sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
3453                            sb.append(StringPool.PERIOD);
3454                    }
3455    
3456                    sb.append(mx);
3457                    sb.append(StringPool.GREATER_THAN);
3458    
3459                    return sb.toString();
3460            }
3461    
3462            @Override
3463            public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
3464                    throws PortalException, SystemException {
3465    
3466                    return getServletURL(
3467                            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
3468            }
3469    
3470            @Override
3471            public String getNewPortletTitle(
3472                    String portletTitle, String oldScopeName, String newScopeName) {
3473    
3474                    if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
3475                            int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
3476    
3477                            portletTitle = portletTitle.substring(0, pos);
3478                    }
3479    
3480                    if (Validator.isNull(newScopeName)) {
3481                            return portletTitle;
3482                    }
3483    
3484                    StringBundler sb = new StringBundler(5);
3485    
3486                    sb.append(portletTitle);
3487                    sb.append(StringPool.SPACE);
3488                    sb.append(StringPool.OPEN_PARENTHESIS);
3489                    sb.append(newScopeName);
3490                    sb.append(StringPool.CLOSE_PARENTHESIS);
3491    
3492                    return sb.toString();
3493            }
3494    
3495            @Override
3496            public HttpServletRequest getOriginalServletRequest(
3497                    HttpServletRequest request) {
3498    
3499                    List<PersistentHttpServletRequestWrapper>
3500                            persistentHttpServletRequestWrappers =
3501                                    new ArrayList<PersistentHttpServletRequestWrapper>();
3502    
3503                    HttpServletRequest originalRequest = request;
3504    
3505                    while (originalRequest.getClass().getName().startsWith(
3506                                            "com.liferay.")) {
3507    
3508                            if (originalRequest instanceof
3509                                            PersistentHttpServletRequestWrapper) {
3510    
3511                                    PersistentHttpServletRequestWrapper
3512                                            persistentHttpServletRequestWrapper =
3513                                                    (PersistentHttpServletRequestWrapper)originalRequest;
3514    
3515                                    persistentHttpServletRequestWrappers.add(
3516                                            persistentHttpServletRequestWrapper.clone());
3517                            }
3518    
3519                            // Get original request so that portlets inside portlets render
3520                            // properly
3521    
3522                            HttpServletRequestWrapper httpServletRequestWrapper =
3523                                    (HttpServletRequestWrapper)originalRequest;
3524    
3525                            originalRequest =
3526                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
3527                    }
3528    
3529                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
3530                                    i--) {
3531    
3532                            HttpServletRequestWrapper httpServletRequestWrapper =
3533                                    persistentHttpServletRequestWrappers.get(i);
3534    
3535                            httpServletRequestWrapper.setRequest(originalRequest);
3536    
3537                            originalRequest = httpServletRequestWrapper;
3538                    }
3539    
3540                    return originalRequest;
3541            }
3542    
3543            /**
3544             * @deprecated As of 6.2.0 renamed to #getSiteGroupId(groupId)
3545             */
3546            @Override
3547            public long getParentGroupId(long groupId)
3548                    throws PortalException, SystemException {
3549    
3550                    return getSiteGroupId(groupId);
3551            }
3552    
3553            @Override
3554            public String getPathContext() {
3555                    return _pathContext;
3556            }
3557    
3558            @Override
3559            public String getPathFriendlyURLPrivateGroup() {
3560                    return _pathFriendlyURLPrivateGroup;
3561            }
3562    
3563            @Override
3564            public String getPathFriendlyURLPrivateUser() {
3565                    return _pathFriendlyURLPrivateUser;
3566            }
3567    
3568            @Override
3569            public String getPathFriendlyURLPublic() {
3570                    return _pathFriendlyURLPublic;
3571            }
3572    
3573            @Override
3574            public String getPathImage() {
3575                    return _pathImage;
3576            }
3577    
3578            @Override
3579            public String getPathMain() {
3580                    return _pathMain;
3581            }
3582    
3583            @Override
3584            public String getPathModule() {
3585                    return _pathModule;
3586            }
3587    
3588            @Override
3589            public String getPathProxy() {
3590                    return _pathProxy;
3591            }
3592    
3593            @Override
3594            public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
3595                    if (Validator.isNull(friendlyURL)) {
3596                            return LayoutConstants.DEFAULT_PLID;
3597                    }
3598    
3599                    String[] urlParts = friendlyURL.split("\\/", 4);
3600    
3601                    if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
3602                            (urlParts.length != 4)) {
3603    
3604                            return LayoutConstants.DEFAULT_PLID;
3605                    }
3606    
3607                    boolean privateLayout = true;
3608    
3609                    String urlPrefix = StringPool.SLASH + urlParts[1];
3610    
3611                    if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
3612                            privateLayout = false;
3613                    }
3614                    else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
3615                                     _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
3616    
3617                            privateLayout = true;
3618                    }
3619                    else {
3620                            return LayoutConstants.DEFAULT_PLID;
3621                    }
3622    
3623                    Group group = null;
3624    
3625                    try {
3626                            group = GroupLocalServiceUtil.getFriendlyURLGroup(
3627                                    companyId, StringPool.SLASH + urlParts[2]);
3628                    }
3629                    catch (Exception e) {
3630                    }
3631    
3632                    if (group == null) {
3633                            return LayoutConstants.DEFAULT_PLID;
3634                    }
3635    
3636                    Layout layout = null;
3637    
3638                    try {
3639                            String layoutFriendlyURL = null;
3640    
3641                            if (urlParts.length == 4) {
3642                                    layoutFriendlyURL = StringPool.SLASH + urlParts[3];
3643    
3644                                    layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3645                                            group.getGroupId(), privateLayout, layoutFriendlyURL);
3646                            }
3647                            else {
3648                                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3649                                            group.getGroupId(), privateLayout,
3650                                            LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
3651    
3652                                    if (!layouts.isEmpty()) {
3653                                            layout = layouts.get(0);
3654                                    }
3655                                    else {
3656                                            return LayoutConstants.DEFAULT_PLID;
3657                                    }
3658                            }
3659    
3660                            return layout.getPlid();
3661                    }
3662                    catch (Exception e) {
3663                    }
3664    
3665                    return LayoutConstants.DEFAULT_PLID;
3666            }
3667    
3668            @Override
3669            public long getPlidFromPortletId(
3670                            long groupId, boolean privateLayout, String portletId)
3671                    throws PortalException, SystemException {
3672    
3673                    long plid = LayoutConstants.DEFAULT_PLID;
3674    
3675                    StringBundler sb = new StringBundler(5);
3676    
3677                    sb.append(groupId);
3678                    sb.append(StringPool.SPACE);
3679                    sb.append(privateLayout);
3680                    sb.append(StringPool.SPACE);
3681                    sb.append(portletId);
3682    
3683                    String key = sb.toString();
3684    
3685                    Long plidObj = _plidToPortletIdMap.get(key);
3686    
3687                    if (plidObj == null) {
3688                            plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
3689    
3690                            if (plid != LayoutConstants.DEFAULT_PLID) {
3691                                    _plidToPortletIdMap.put(key, plid);
3692                            }
3693                    }
3694                    else {
3695                            plid = plidObj.longValue();
3696    
3697                            boolean validPlid = false;
3698    
3699                            try {
3700                                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
3701    
3702                                    LayoutTypePortlet layoutTypePortlet =
3703                                            (LayoutTypePortlet)layout.getLayoutType();
3704    
3705                                    if (layoutTypePortlet.hasDefaultScopePortletId(
3706                                                    groupId, portletId)) {
3707    
3708                                            validPlid = true;
3709                                    }
3710                            }
3711                            catch (Exception e) {
3712                            }
3713    
3714                            if (!validPlid) {
3715                                    _plidToPortletIdMap.remove(key);
3716    
3717                                    plid = doGetPlidFromPortletId(
3718                                            groupId, privateLayout, portletId);
3719    
3720                                    if (plid != LayoutConstants.DEFAULT_PLID) {
3721                                            _plidToPortletIdMap.put(key, plid);
3722                                    }
3723                            }
3724                    }
3725    
3726                    return plid;
3727            }
3728    
3729            @Override
3730            public long getPlidFromPortletId(long groupId, String portletId)
3731                    throws PortalException, SystemException {
3732    
3733                    long plid = getPlidFromPortletId(groupId, false, portletId);
3734    
3735                    if (plid == LayoutConstants.DEFAULT_PLID) {
3736                            plid = getPlidFromPortletId(groupId, true, portletId);
3737                    }
3738    
3739                    if (plid == LayoutConstants.DEFAULT_PLID) {
3740                            if (_log.isDebugEnabled()) {
3741                                    _log.debug(
3742                                            "Portlet " + portletId +
3743                                                    " does not exist on a page in group " + groupId);
3744                            }
3745                    }
3746    
3747                    return plid;
3748            }
3749    
3750            @Override
3751            public String getPortalLibDir() {
3752                    return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3753            }
3754    
3755            /**
3756             * @deprecated As of 6.1.0, replaced by {@link #getPortalPort(boolean)}
3757             */
3758            @Override
3759            public int getPortalPort() {
3760                    return _portalPort.get();
3761            }
3762    
3763            @Override
3764            public int getPortalPort(boolean secure) {
3765                    if (secure) {
3766                            return _securePortalPort.get();
3767                    }
3768                    else {
3769                            return _portalPort.get();
3770                    }
3771            }
3772    
3773            @Override
3774            public Properties getPortalProperties() {
3775                    return PropsUtil.getProperties();
3776            }
3777    
3778            @Override
3779            public String getPortalURL(HttpServletRequest request) {
3780                    return getPortalURL(request, isSecure(request));
3781            }
3782    
3783            @Override
3784            public String getPortalURL(HttpServletRequest request, boolean secure) {
3785                    return getPortalURL(
3786                            request.getServerName(), request.getServerPort(), secure);
3787            }
3788    
3789            @Override
3790            public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3791                    throws PortalException, SystemException {
3792    
3793                    String serverName = themeDisplay.getServerName();
3794    
3795                    if (layout == null) {
3796                            layout = themeDisplay.getLayout();
3797                    }
3798    
3799                    if (layout != null) {
3800                            LayoutSet layoutSet = layout.getLayoutSet();
3801    
3802                            String virtualHostname = layoutSet.getVirtualHostname();
3803    
3804                            String domain = HttpUtil.getDomain(themeDisplay.getURLPortal());
3805    
3806                            if (Validator.isNotNull(virtualHostname) &&
3807                                    domain.startsWith(virtualHostname)) {
3808    
3809                                    serverName = virtualHostname;
3810                            }
3811                    }
3812    
3813                    return getPortalURL(
3814                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
3815            }
3816    
3817            @Override
3818            public String getPortalURL(PortletRequest portletRequest) {
3819                    return getPortalURL(portletRequest, portletRequest.isSecure());
3820            }
3821    
3822            @Override
3823            public String getPortalURL(PortletRequest portletRequest, boolean secure) {
3824                    return getPortalURL(
3825                            portletRequest.getServerName(), portletRequest.getServerPort(),
3826                            secure);
3827            }
3828    
3829            @Override
3830            public String getPortalURL(
3831                    String serverName, int serverPort, boolean secure) {
3832    
3833                    StringBundler sb = new StringBundler();
3834    
3835                    boolean https =
3836                            secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL);
3837    
3838                    if (https) {
3839                            sb.append(Http.HTTPS_WITH_SLASH);
3840                    }
3841                    else {
3842                            sb.append(Http.HTTP_WITH_SLASH);
3843                    }
3844    
3845                    if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
3846                            sb.append(serverName);
3847                    }
3848                    else {
3849                            sb.append(PropsValues.WEB_SERVER_HOST);
3850                    }
3851    
3852                    if (!https) {
3853                            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
3854                                    if ((serverPort != Http.HTTP_PORT) &&
3855                                            (serverPort != Http.HTTPS_PORT)) {
3856    
3857                                            sb.append(StringPool.COLON);
3858                                            sb.append(serverPort);
3859                                    }
3860                            }
3861                            else {
3862                                    if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
3863                                            sb.append(StringPool.COLON);
3864                                            sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
3865                                    }
3866                            }
3867                    }
3868                    else {
3869                            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
3870                                    if ((serverPort != Http.HTTP_PORT) &&
3871                                            (serverPort != Http.HTTPS_PORT)) {
3872    
3873                                            sb.append(StringPool.COLON);
3874                                            sb.append(serverPort);
3875                                    }
3876                            }
3877                            else {
3878                                    if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
3879                                            sb.append(StringPool.COLON);
3880                                            sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
3881                                    }
3882                            }
3883                    }
3884    
3885                    return sb.toString();
3886            }
3887    
3888            @Override
3889            public String getPortalURL(ThemeDisplay themeDisplay)
3890                    throws PortalException, SystemException {
3891    
3892                    return getPortalURL(null, themeDisplay);
3893            }
3894    
3895            @Override
3896            public String getPortalWebDir() {
3897                    return PropsValues.LIFERAY_WEB_PORTAL_DIR;
3898            }
3899    
3900            /**
3901             * @deprecated As of 6.2.0, replaced by {@link
3902             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelist}
3903             */
3904            @Override
3905            public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
3906                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
3907            }
3908    
3909            /**
3910             * @deprecated As of 6.2.0, replaced by {@link
3911             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelistActions}
3912             */
3913            @Override
3914            public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
3915                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
3916            }
3917    
3918            /**
3919             * @deprecated As of 6.1.0, replaced by {@link
3920             *             #getPortletBreadcrumbs(HttpServletRequest)}
3921             */
3922            @Override
3923            public List<BreadcrumbEntry> getPortletBreadcrumbList(
3924                    HttpServletRequest request) {
3925    
3926                    return getPortletBreadcrumbs(request);
3927            }
3928    
3929            @Override
3930            public List<BreadcrumbEntry> getPortletBreadcrumbs(
3931                    HttpServletRequest request) {
3932    
3933                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3934                            WebKeys.THEME_DISPLAY);
3935    
3936                    PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
3937    
3938                    String name = WebKeys.PORTLET_BREADCRUMBS;
3939    
3940                    String portletName = portletDisplay.getPortletName();
3941    
3942                    if (Validator.isNotNull(portletDisplay.getId()) &&
3943                            !portletName.equals(PortletKeys.BREADCRUMB) &&
3944                            !portletDisplay.isFocused()) {
3945    
3946                            name = name.concat(
3947                                    StringPool.UNDERLINE.concat(portletDisplay.getId()));
3948                    }
3949    
3950                    return (List<BreadcrumbEntry>)request.getAttribute(name);
3951            }
3952    
3953            @Override
3954            public PortletConfig getPortletConfig(
3955                            long companyId, String portletId, ServletContext servletContext)
3956                    throws PortletException, SystemException {
3957    
3958                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
3959                            companyId, portletId);
3960    
3961                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
3962                            portlet, servletContext);
3963    
3964                    return invokerPortlet.getPortletConfig();
3965            }
3966    
3967            @Override
3968            public String getPortletDescription(
3969                    Portlet portlet, ServletContext servletContext, Locale locale) {
3970    
3971                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3972                            portlet, servletContext);
3973    
3974                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3975    
3976                    String portletDescription = ResourceBundleUtil.getString(
3977                            resourceBundle,
3978                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
3979                                    StringPool.PERIOD).concat(portlet.getRootPortletId()));
3980    
3981                    if (Validator.isNull(portletDescription)) {
3982                            portletDescription = ResourceBundleUtil.getString(
3983                                    resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
3984                    }
3985    
3986                    return portletDescription;
3987            }
3988    
3989            @Override
3990            public String getPortletDescription(Portlet portlet, User user) {
3991                    return getPortletDescription(portlet.getPortletId(), user);
3992            }
3993    
3994            @Override
3995            public String getPortletDescription(String portletId, Locale locale) {
3996                    return LanguageUtil.get(
3997                            locale,
3998                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
3999                                    StringPool.PERIOD).concat(portletId));
4000            }
4001    
4002            @Override
4003            public String getPortletDescription(String portletId, String languageId) {
4004                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4005    
4006                    return getPortletDescription(portletId, locale);
4007            }
4008    
4009            @Override
4010            public String getPortletDescription(String portletId, User user) {
4011                    return LanguageUtil.get(
4012                            user.getLocale(),
4013                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4014                                    StringPool.PERIOD).concat(portletId));
4015            }
4016    
4017            public LayoutQueryStringComposite
4018                    getPortletFriendlyURLMapperLayoutQueryStringComposite(
4019                            long groupId, boolean privateLayout, String url,
4020                            Map<String, String[]> params, Map<String, Object> requestContext)
4021                    throws PortalException, SystemException {
4022    
4023                    boolean foundFriendlyURLMapper = false;
4024    
4025                    String friendlyURL = url;
4026                    String queryString = StringPool.BLANK;
4027    
4028                    List<Portlet> portlets =
4029                            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
4030    
4031                    for (Portlet portlet : portlets) {
4032                            FriendlyURLMapper friendlyURLMapper =
4033                                    portlet.getFriendlyURLMapperInstance();
4034    
4035                            if (url.endsWith(
4036                                            StringPool.SLASH + friendlyURLMapper.getMapping())) {
4037    
4038                                    url += StringPool.SLASH;
4039                            }
4040    
4041                            int pos = -1;
4042    
4043                            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4044                                    pos = url.indexOf(
4045                                            FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
4046                                                    StringPool.SLASH);
4047                            }
4048                            else {
4049                                    pos = url.indexOf(
4050                                            StringPool.SLASH + friendlyURLMapper.getMapping() +
4051                                                    StringPool.SLASH);
4052                            }
4053    
4054                            if (pos != -1) {
4055                                    foundFriendlyURLMapper = true;
4056    
4057                                    friendlyURL = url.substring(0, pos);
4058    
4059                                    InheritableMap<String, String[]> actualParams =
4060                                            new InheritableMap<String, String[]>();
4061    
4062                                    if (params != null) {
4063                                            actualParams.setParentMap(params);
4064                                    }
4065    
4066                                    Map<String, String> prpIdentifiers =
4067                                            new HashMap<String, String>();
4068    
4069                                    Set<PublicRenderParameter> publicRenderParameters =
4070                                            portlet.getPublicRenderParameters();
4071    
4072                                    for (PublicRenderParameter publicRenderParameter :
4073                                                    publicRenderParameters) {
4074    
4075                                            QName qName = publicRenderParameter.getQName();
4076    
4077                                            String publicRenderParameterIdentifier =
4078                                                    qName.getLocalPart();
4079                                            String publicRenderParameterName =
4080                                                    PortletQNameUtil.getPublicRenderParameterName(qName);
4081    
4082                                            prpIdentifiers.put(
4083                                                    publicRenderParameterIdentifier,
4084                                                    publicRenderParameterName);
4085                                    }
4086    
4087                                    FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
4088    
4089                                    if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4090                                            friendlyURLMapper.populateParams(
4091                                                    url.substring(pos + 2), actualParams, requestContext);
4092                                    }
4093                                    else {
4094                                            friendlyURLMapper.populateParams(
4095                                                    url.substring(pos), actualParams, requestContext);
4096                                    }
4097    
4098                                    queryString =
4099                                            StringPool.AMPERSAND +
4100                                                    HttpUtil.parameterMapToString(actualParams, false);
4101    
4102                                    break;
4103                            }
4104                    }
4105    
4106                    if (!foundFriendlyURLMapper) {
4107                            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
4108    
4109                            if (x != -1) {
4110                                    int y = url.indexOf(CharPool.SLASH, x + 3);
4111    
4112                                    if (y == -1) {
4113                                            y = url.length();
4114                                    }
4115    
4116                                    String ppid = url.substring(x + 3, y);
4117    
4118                                    if (Validator.isNotNull(ppid)) {
4119                                            friendlyURL = url.substring(0, x);
4120    
4121                                            Map<String, String[]> actualParams = null;
4122    
4123                                            if (params != null) {
4124                                                    actualParams = new HashMap<String, String[]>(params);
4125                                            }
4126                                            else {
4127                                                    actualParams = new HashMap<String, String[]>();
4128                                            }
4129    
4130                                            actualParams.put("p_p_id", new String[] {ppid});
4131                                            actualParams.put("p_p_lifecycle", new String[] {"0"});
4132                                            actualParams.put(
4133                                                    "p_p_state",
4134                                                    new String[] {WindowState.MAXIMIZED.toString()});
4135                                            actualParams.put(
4136                                                    "p_p_mode", new String[] {PortletMode.VIEW.toString()});
4137    
4138                                            queryString =
4139                                                    StringPool.AMPERSAND +
4140                                                            HttpUtil.parameterMapToString(actualParams, false);
4141                                    }
4142                            }
4143                    }
4144    
4145                    friendlyURL = StringUtil.replace(
4146                            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
4147    
4148                    if (friendlyURL.endsWith(StringPool.SLASH)) {
4149                            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
4150                    }
4151    
4152                    Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
4153                            groupId, privateLayout, friendlyURL);
4154    
4155                    return new LayoutQueryStringComposite(layout, queryString);
4156            }
4157    
4158            @Override
4159            public String getPortletId(HttpServletRequest request) {
4160                    LiferayPortletConfig liferayPortletConfig =
4161                            (LiferayPortletConfig)request.getAttribute(
4162                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4163    
4164                    if (liferayPortletConfig != null) {
4165                            return liferayPortletConfig.getPortletId();
4166                    }
4167                    else {
4168                            return null;
4169                    }
4170            }
4171    
4172            @Override
4173            public String getPortletId(PortletRequest portletRequest) {
4174                    LiferayPortletConfig liferayPortletConfig =
4175                            (LiferayPortletConfig)portletRequest.getAttribute(
4176                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4177    
4178                    if (liferayPortletConfig != null) {
4179                            return liferayPortletConfig.getPortletId();
4180                    }
4181                    else {
4182                            return null;
4183                    }
4184            }
4185    
4186            @Override
4187            public String getPortletLongTitle(Portlet portlet, Locale locale) {
4188                    return getPortletLongTitle(portlet.getPortletId(), locale);
4189            }
4190    
4191            @Override
4192            public String getPortletLongTitle(
4193                    Portlet portlet, ServletContext servletContext, Locale locale) {
4194    
4195                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4196                            portlet, servletContext);
4197    
4198                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4199    
4200                    try {
4201                            String portletLongTitle = resourceBundle.getString(
4202                                    JavaConstants.JAVAX_PORTLET_LONG_TITLE);
4203    
4204                            if (portletLongTitle.startsWith(
4205                                            JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
4206    
4207                                    portletLongTitle = getPortletTitle(
4208                                            portlet, servletContext, locale);
4209                            }
4210    
4211                            return portletLongTitle;
4212                    }
4213                    catch (Exception e) {
4214                            return getPortletTitle(portlet, servletContext, locale);
4215                    }
4216            }
4217    
4218            @Override
4219            public String getPortletLongTitle(Portlet portlet, String languageId) {
4220                    return getPortletLongTitle(portlet.getPortletId(), languageId);
4221            }
4222    
4223            @Override
4224            public String getPortletLongTitle(Portlet portlet, User user) {
4225                    return getPortletLongTitle(portlet.getPortletId(), user);
4226            }
4227    
4228            @Override
4229            public String getPortletLongTitle(String portletId, Locale locale) {
4230                    String portletLongTitle = LanguageUtil.get(
4231                            locale,
4232                            JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
4233                                    StringPool.PERIOD).concat(portletId),
4234                            StringPool.BLANK);
4235    
4236                    if (Validator.isNull(portletLongTitle)) {
4237                            portletLongTitle = getPortletTitle(portletId, locale);
4238                    }
4239    
4240                    return portletLongTitle;
4241            }
4242    
4243            @Override
4244            public String getPortletLongTitle(String portletId, String languageId) {
4245                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4246    
4247                    return getPortletLongTitle(portletId, locale);
4248            }
4249    
4250            @Override
4251            public String getPortletLongTitle(String portletId, User user) {
4252                    return getPortletLongTitle(portletId, user.getLocale());
4253            }
4254    
4255            @Override
4256            public String getPortletNamespace(String portletId) {
4257                    return StringPool.UNDERLINE.concat(portletId).concat(
4258                            StringPool.UNDERLINE);
4259            }
4260    
4261            @Override
4262            public String getPortletTitle(Portlet portlet, Locale locale) {
4263                    return getPortletTitle(portlet.getPortletId(), locale);
4264            }
4265    
4266            @Override
4267            public String getPortletTitle(
4268                    Portlet portlet, ServletContext servletContext, Locale locale) {
4269    
4270                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4271                            portlet, servletContext);
4272    
4273                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4274    
4275                    String portletTitle = ResourceBundleUtil.getString(
4276                            resourceBundle,
4277                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4278                                    portlet.getRootPortletId()));
4279    
4280                    if (Validator.isNull(portletTitle)) {
4281                            portletTitle = ResourceBundleUtil.getString(
4282                                    resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4283                    }
4284    
4285                    return portletTitle;
4286            }
4287    
4288            @Override
4289            public String getPortletTitle(Portlet portlet, String languageId) {
4290                    return getPortletTitle(portlet.getPortletId(), languageId);
4291            }
4292    
4293            @Override
4294            public String getPortletTitle(Portlet portlet, User user) {
4295                    return getPortletTitle(portlet.getPortletId(), user);
4296            }
4297    
4298            @Override
4299            public String getPortletTitle(RenderRequest renderRequest) {
4300                    String portletId = (String)renderRequest.getAttribute(
4301                            WebKeys.PORTLET_ID);
4302    
4303                    Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);
4304    
4305                    HttpServletRequest request = getHttpServletRequest(renderRequest);
4306    
4307                    ServletContext servletContext = (ServletContext)request.getAttribute(
4308                            WebKeys.CTX);
4309    
4310                    Locale locale = renderRequest.getLocale();
4311    
4312                    return getPortletTitle(portlet, servletContext, locale);
4313            }
4314    
4315            @Override
4316            public String getPortletTitle(RenderResponse renderResponse) {
4317                    PortletResponseImpl portletResponseImpl =
4318                            PortletResponseImpl.getPortletResponseImpl(renderResponse);
4319    
4320                    return ((RenderResponseImpl)portletResponseImpl).getTitle();
4321            }
4322    
4323            @Override
4324            public String getPortletTitle(String portletId, Locale locale) {
4325                    return LanguageUtil.get(
4326                            locale,
4327                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4328                                    portletId));
4329            }
4330    
4331            @Override
4332            public String getPortletTitle(String portletId, String languageId) {
4333                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4334    
4335                    return getPortletTitle(portletId, locale);
4336            }
4337    
4338            @Override
4339            public String getPortletTitle(String portletId, User user) {
4340                    return LanguageUtil.get(
4341                            user.getLocale(),
4342                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4343                                    portletId));
4344            }
4345    
4346            @Override
4347            public String getPortletXmlFileName() throws SystemException {
4348                    if (PrefsPropsUtil.getBoolean(
4349                                    PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
4350                                    PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
4351    
4352                            return PORTLET_XML_FILE_NAME_CUSTOM;
4353                    }
4354                    else {
4355                            return PORTLET_XML_FILE_NAME_STANDARD;
4356                    }
4357            }
4358    
4359            @Override
4360            public PortletPreferences getPreferences(HttpServletRequest request) {
4361                    RenderRequest renderRequest = (RenderRequest)request.getAttribute(
4362                            JavaConstants.JAVAX_PORTLET_REQUEST);
4363    
4364                    PortletPreferences portletPreferences = null;
4365    
4366                    if (renderRequest != null) {
4367                            PortletPreferencesWrapper portletPreferencesWrapper =
4368                                    (PortletPreferencesWrapper)renderRequest.getPreferences();
4369    
4370                            portletPreferences =
4371                                    portletPreferencesWrapper.getPortletPreferencesImpl();
4372                    }
4373    
4374                    return portletPreferences;
4375            }
4376    
4377            @Override
4378            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
4379                    PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
4380    
4381                    return portletBag.getPreferencesValidatorInstance();
4382            }
4383    
4384            @Override
4385            public String getRelativeHomeURL(HttpServletRequest request)
4386                    throws PortalException, SystemException {
4387    
4388                    Company company = getCompany(request);
4389    
4390                    String homeURL = company.getHomeURL();
4391    
4392                    if (Validator.isNull(homeURL)) {
4393                            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
4394                    }
4395    
4396                    return homeURL;
4397            }
4398    
4399            @Override
4400            public long getScopeGroupId(HttpServletRequest request)
4401                    throws PortalException, SystemException {
4402    
4403                    String portletId = getPortletId(request);
4404    
4405                    return getScopeGroupId(request, portletId);
4406            }
4407    
4408            @Override
4409            public long getScopeGroupId(HttpServletRequest request, String portletId)
4410                    throws PortalException, SystemException {
4411    
4412                    return getScopeGroupId(request, portletId, false);
4413            }
4414    
4415            @Override
4416            public long getScopeGroupId(
4417                            HttpServletRequest request, String portletId,
4418                            boolean checkStagingGroup)
4419                    throws PortalException, SystemException {
4420    
4421                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4422    
4423                    long scopeGroupId = 0;
4424    
4425                    if (layout != null) {
4426                            Group group = layout.getGroup();
4427    
4428                            if (group.isControlPanel()) {
4429                                    long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
4430    
4431                                    Group doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
4432    
4433                                    if ((doAsGroupId <= 0) || (doAsGroup == null)) {
4434                                            doAsGroupId = getDefaultScopeGroupId(group.getCompanyId());
4435                                    }
4436    
4437                                    if (doAsGroupId > 0) {
4438                                            scopeGroupId = doAsGroupId;
4439                                    }
4440    
4441                                    group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
4442    
4443                                    if ((group != null) && group.hasStagingGroup()) {
4444                                            try {
4445                                                    Group stagingGroup = group.getStagingGroup();
4446    
4447                                                    scopeGroupId = stagingGroup.getGroupId();
4448                                            }
4449                                            catch (Exception e) {
4450                                            }
4451                                    }
4452                            }
4453    
4454                            if ((portletId != null) &&
4455                                    (group.isStaged() || group.isStagingGroup())) {
4456    
4457                                    Group liveGroup = group;
4458    
4459                                    if (group.isStagingGroup()) {
4460                                            liveGroup = group.getLiveGroup();
4461                                    }
4462    
4463                                    if (liveGroup.isStaged() &&
4464                                            !liveGroup.isStagedPortlet(portletId)) {
4465    
4466                                            Layout liveGroupLayout =
4467                                                    LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
4468                                                                    layout.getUuid(), liveGroup.getGroupId(),
4469                                                                    layout.isPrivateLayout());
4470    
4471                                            if ((liveGroupLayout != null) &&
4472                                                    liveGroupLayout.hasScopeGroup()) {
4473    
4474                                                    scopeGroupId = getScopeGroupId(
4475                                                            liveGroupLayout, portletId);
4476                                            }
4477                                            else if (checkStagingGroup &&
4478                                                             !liveGroup.isStagedRemotely()) {
4479    
4480                                                    Group stagingGroup = liveGroup.getStagingGroup();
4481    
4482                                                    scopeGroupId = stagingGroup.getGroupId();
4483                                            }
4484                                            else {
4485                                                    scopeGroupId = liveGroup.getGroupId();
4486                                            }
4487                                    }
4488                            }
4489                    }
4490    
4491                    if (scopeGroupId <= 0) {
4492                            scopeGroupId = getScopeGroupId(layout, portletId);
4493                    }
4494    
4495                    return scopeGroupId;
4496            }
4497    
4498            @Override
4499            public long getScopeGroupId(Layout layout) {
4500                    if (layout == null) {
4501                            return 0;
4502                    }
4503                    else {
4504                            return layout.getGroupId();
4505                    }
4506            }
4507    
4508            @Override
4509            public long getScopeGroupId(Layout layout, String portletId) {
4510                    if (layout == null) {
4511                            return 0;
4512                    }
4513    
4514                    if (Validator.isNull(portletId)) {
4515                            return layout.getGroupId();
4516                    }
4517    
4518                    try {
4519                            PortletPreferences portletSetup =
4520                                    PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
4521                                            layout, portletId);
4522    
4523                            String scopeType = GetterUtil.getString(
4524                                    portletSetup.getValue("lfrScopeType", null));
4525    
4526                            if (Validator.isNull(scopeType)) {
4527                                    return layout.getGroupId();
4528                            }
4529    
4530                            if (scopeType.equals("company")) {
4531                                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4532                                            layout.getCompanyId());
4533    
4534                                    return companyGroup.getGroupId();
4535                            }
4536                            else {
4537                                    String scopeLayoutUuid = GetterUtil.getString(
4538                                            portletSetup.getValue("lfrScopeLayoutUuid", null));
4539    
4540                                    Layout scopeLayout =
4541                                            LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
4542                                                    scopeLayoutUuid, layout.getGroupId(),
4543                                                    layout.isPrivateLayout());
4544    
4545                                    Group scopeGroup = scopeLayout.getScopeGroup();
4546    
4547                                    return scopeGroup.getGroupId();
4548                            }
4549                    }
4550                    catch (Exception e) {
4551                            return layout.getGroupId();
4552                    }
4553            }
4554    
4555            @Override
4556            public long getScopeGroupId(long plid) {
4557                    Layout layout = null;
4558    
4559                    try {
4560                            layout = LayoutLocalServiceUtil.getLayout(plid);
4561                    }
4562                    catch (Exception e) {
4563                    }
4564    
4565                    return getScopeGroupId(layout);
4566            }
4567    
4568            @Override
4569            public long getScopeGroupId(PortletRequest portletRequest)
4570                    throws PortalException, SystemException {
4571    
4572                    return getScopeGroupId(getHttpServletRequest(portletRequest));
4573            }
4574    
4575            @Override
4576            public User getSelectedUser(HttpServletRequest request)
4577                    throws PortalException, SystemException {
4578    
4579                    return getSelectedUser(request, true);
4580            }
4581    
4582            @Override
4583            public User getSelectedUser(
4584                            HttpServletRequest request, boolean checkPermission)
4585                    throws PortalException, SystemException {
4586    
4587                    long userId = ParamUtil.getLong(request, "p_u_i_d");
4588    
4589                    User user = null;
4590    
4591                    try {
4592                            if (checkPermission) {
4593                                    user = UserServiceUtil.getUserById(userId);
4594                            }
4595                            else {
4596                                    user = UserLocalServiceUtil.getUserById(userId);
4597                            }
4598                    }
4599                    catch (NoSuchUserException nsue) {
4600                    }
4601    
4602                    return user;
4603            }
4604    
4605            @Override
4606            public User getSelectedUser(PortletRequest portletRequest)
4607                    throws PortalException, SystemException {
4608    
4609                    return getSelectedUser(portletRequest, true);
4610            }
4611    
4612            @Override
4613            public User getSelectedUser(
4614                            PortletRequest portletRequest, boolean checkPermission)
4615                    throws PortalException, SystemException {
4616    
4617                    return getSelectedUser(
4618                            getHttpServletRequest(portletRequest), checkPermission);
4619            }
4620    
4621            @Override
4622            public Map<String, List<Portlet>> getSiteAdministrationCategoriesMap(
4623                            HttpServletRequest request)
4624                    throws SystemException {
4625    
4626                    return getCategoriesMap(
4627                            request, WebKeys.SITE_ADMINISTRATION_CATEGORIES_MAP,
4628                            PortletCategoryKeys.SITE_ADMINISTRATION_ALL);
4629            }
4630    
4631            @Override
4632            public PortletURL getSiteAdministrationURL(
4633                            HttpServletRequest request, ThemeDisplay themeDisplay)
4634                    throws SystemException {
4635    
4636                    Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4637    
4638                    if (portlet == null) {
4639                            return null;
4640                    }
4641    
4642                    return getSiteAdministrationURL(
4643                            request, themeDisplay, portlet.getPortletName());
4644            }
4645    
4646            @Override
4647            public PortletURL getSiteAdministrationURL(
4648                    HttpServletRequest request, ThemeDisplay themeDisplay,
4649                    String portletName) {
4650    
4651                    LiferayPortletURL siteAdministrationURL = PortletURLFactoryUtil.create(
4652                            request, portletName, themeDisplay.getPlid(),
4653                            PortletRequest.RENDER_PHASE);
4654    
4655                    siteAdministrationURL.setControlPanelCategory(
4656                            PortletCategoryKeys.SITES);
4657                    siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4658                    siteAdministrationURL.setParameter(
4659                            "redirect", themeDisplay.getURLCurrent());
4660    
4661                    return siteAdministrationURL;
4662            }
4663    
4664            @Override
4665            public PortletURL getSiteAdministrationURL(
4666                            PortletResponse portletResponse, ThemeDisplay themeDisplay)
4667                    throws SystemException {
4668    
4669                    Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4670    
4671                    if (portlet == null) {
4672                            return null;
4673                    }
4674    
4675                    return getSiteAdministrationURL(
4676                            portletResponse, themeDisplay, portlet.getPortletName());
4677            }
4678    
4679            @Override
4680            public PortletURL getSiteAdministrationURL(
4681                    PortletResponse portletResponse, ThemeDisplay themeDisplay,
4682                    String portletName) {
4683    
4684                    LiferayPortletResponse liferayPortletResponse =
4685                            (LiferayPortletResponse)portletResponse;
4686    
4687                    LiferayPortletURL siteAdministrationURL =
4688                            liferayPortletResponse.createRenderURL(portletName);
4689    
4690                    siteAdministrationURL.setControlPanelCategory(
4691                            PortletCategoryKeys.SITES);
4692                    siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4693                    siteAdministrationURL.setParameter(
4694                            "redirect", themeDisplay.getURLCurrent());
4695    
4696                    return siteAdministrationURL;
4697            }
4698    
4699            @Override
4700            public long[] getSiteAndCompanyGroupIds(long groupId)
4701                    throws PortalException, SystemException {
4702    
4703                    Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
4704    
4705                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4706                            scopeGroup.getCompanyId());
4707    
4708                    if (scopeGroup.isLayout()) {
4709                            return new long[] {
4710                                    groupId, scopeGroup.getParentGroupId(),
4711                                    companyGroup.getGroupId()
4712                            };
4713                    }
4714                    else if (scopeGroup.isLayoutSetPrototype() ||
4715                                     scopeGroup.isRegularSite()) {
4716    
4717                            return new long[] {groupId, companyGroup.getGroupId()};
4718                    }
4719                    else {
4720                            return new long[] {companyGroup.getGroupId()};
4721                    }
4722            }
4723    
4724            @Override
4725            public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
4726                    throws PortalException, SystemException {
4727    
4728                    return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
4729            }
4730    
4731            @Override
4732            public Locale getSiteDefaultLocale(long groupId)
4733                    throws PortalException, SystemException {
4734    
4735                    if (groupId <= 0) {
4736                            return LocaleUtil.getDefault();
4737                    }
4738    
4739                    Group group = GroupLocalServiceUtil.getGroup(groupId);
4740    
4741                    Group liveGroup = group;
4742    
4743                    if (group.isStagingGroup()) {
4744                            liveGroup = group.getLiveGroup();
4745                    }
4746    
4747                    if (LanguageUtil.isInheritLocales(liveGroup.getGroupId())) {
4748                            return LocaleUtil.getDefault();
4749                    }
4750    
4751                    UnicodeProperties typeSettingsProperties =
4752                            liveGroup.getTypeSettingsProperties();
4753    
4754                    User defaultUser = UserLocalServiceUtil.getDefaultUser(
4755                            group.getCompanyId());
4756    
4757                    String languageId = GetterUtil.getString(
4758                            typeSettingsProperties.getProperty("languageId"),
4759                            defaultUser.getLanguageId());
4760    
4761                    return LocaleUtil.fromLanguageId(languageId);
4762            }
4763    
4764            @Override
4765            public long getSiteGroupId(long groupId)
4766                    throws PortalException, SystemException {
4767    
4768                    if (groupId <= 0) {
4769                            return 0;
4770                    }
4771    
4772                    Group group = GroupLocalServiceUtil.getGroup(groupId);
4773    
4774                    long siteGroupId = groupId;
4775    
4776                    if (group.isLayout()) {
4777                            siteGroupId = group.getParentGroupId();
4778                    }
4779    
4780                    return siteGroupId;
4781            }
4782    
4783            @Override
4784            public String getSiteLoginURL(ThemeDisplay themeDisplay)
4785                    throws PortalException, SystemException {
4786    
4787                    if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
4788                            return null;
4789                    }
4790    
4791                    List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
4792    
4793                    if (layouts == null) {
4794                            return null;
4795                    }
4796    
4797                    for (Layout layout : layouts) {
4798                            String friendlyURL = layout.getFriendlyURL(
4799                                    themeDisplay.getLocale());
4800    
4801                            if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
4802                                    if (themeDisplay.getLayout() == null) {
4803                                            break;
4804                                    }
4805    
4806                                    String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
4807                                            layout.getLayoutSet(), themeDisplay);
4808    
4809                                    return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
4810                            }
4811                    }
4812    
4813                    return null;
4814            }
4815    
4816            @Override
4817            public String getStaticResourceURL(HttpServletRequest request, String uri) {
4818                    return getStaticResourceURL(request, uri, null, 0);
4819            }
4820    
4821            @Override
4822            public String getStaticResourceURL(
4823                    HttpServletRequest request, String uri, long timestamp) {
4824    
4825                    return getStaticResourceURL(request, uri, null, timestamp);
4826            }
4827    
4828            @Override
4829            public String getStaticResourceURL(
4830                    HttpServletRequest request, String uri, String queryString) {
4831    
4832                    return getStaticResourceURL(request, uri, queryString, 0);
4833            }
4834    
4835            @Override
4836            public String getStaticResourceURL(
4837                    HttpServletRequest request, String uri, String queryString,
4838                    long timestamp) {
4839    
4840                    if (uri.indexOf(CharPool.QUESTION) != -1) {
4841                            return uri;
4842                    }
4843    
4844                    if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
4845                            uri = uri.substring(1);
4846                    }
4847    
4848                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4849                            WebKeys.THEME_DISPLAY);
4850    
4851                    Theme theme = themeDisplay.getTheme();
4852                    ColorScheme colorScheme = themeDisplay.getColorScheme();
4853    
4854                    Map<String, String[]> parameterMap = null;
4855    
4856                    if (Validator.isNotNull(queryString)) {
4857                            parameterMap = HttpUtil.getParameterMap(queryString);
4858                    }
4859    
4860                    StringBundler sb = new StringBundler();
4861    
4862                    // URI
4863    
4864                    sb.append(uri);
4865                    sb.append(StringPool.QUESTION);
4866    
4867                    // Browser id
4868    
4869                    if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
4870                            sb.append("&browserId=");
4871                            sb.append(BrowserSnifferUtil.getBrowserId(request));
4872                    }
4873    
4874                    // Theme and color scheme
4875    
4876                    if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
4877                            ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
4878    
4879                            sb.append("&themeId=");
4880                            sb.append(theme.getThemeId());
4881                    }
4882    
4883                    if (uri.endsWith(".jsp") &&
4884                            ((parameterMap == null) ||
4885                             !parameterMap.containsKey("colorSchemeId"))) {
4886    
4887                            sb.append("&colorSchemeId=");
4888                            sb.append(colorScheme.getColorSchemeId());
4889                    }
4890    
4891                    // Minifier
4892    
4893                    if ((parameterMap == null) ||
4894                            !parameterMap.containsKey("minifierType")) {
4895    
4896                            String minifierType = StringPool.BLANK;
4897    
4898                            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
4899                                    (uri.endsWith(".jsp") && uri.contains("/css/"))) {
4900    
4901                                    if (themeDisplay.isThemeCssFastLoad()) {
4902                                            minifierType = "css";
4903                                    }
4904                            }
4905                            else if (themeDisplay.isThemeJsFastLoad()) {
4906                                    minifierType = "js";
4907                            }
4908    
4909                            if (Validator.isNotNull(minifierType)) {
4910                                    sb.append("&minifierType=");
4911                                    sb.append(minifierType);
4912                            }
4913                    }
4914    
4915                    // Query string
4916    
4917                    if (Validator.isNotNull(queryString)) {
4918                            if (!queryString.startsWith(StringPool.AMPERSAND)) {
4919                                    sb.append(StringPool.AMPERSAND);
4920                            }
4921    
4922                            sb.append(queryString);
4923                    }
4924    
4925                    // Language id
4926    
4927                    sb.append("&languageId=");
4928                    sb.append(themeDisplay.getLanguageId());
4929    
4930                    // Build number
4931    
4932                    sb.append("&b=");
4933                    sb.append(ReleaseInfo.getBuildNumber());
4934    
4935                    // Timestamp
4936    
4937                    if ((parameterMap == null) || !parameterMap.containsKey("t")) {
4938                            if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
4939                                    ServletContext servletContext =
4940                                            (ServletContext)request.getAttribute(WebKeys.CTX);
4941    
4942                                    timestamp = ServletContextUtil.getLastModified(
4943                                            servletContext, uri, true);
4944                            }
4945    
4946                            if (timestamp == 0) {
4947                                    timestamp = theme.getTimestamp();
4948                            }
4949    
4950                            sb.append("&t=");
4951                            sb.append(timestamp);
4952                    }
4953    
4954                    String url = sb.toString();
4955    
4956                    url = StringUtil.replace(url, "?&", StringPool.QUESTION);
4957    
4958                    return url;
4959            }
4960    
4961            @Override
4962            public String getStrutsAction(HttpServletRequest request) {
4963                    String strutsAction = ParamUtil.getString(request, "struts_action");
4964    
4965                    if (Validator.isNotNull(strutsAction)) {
4966    
4967                            // This method should only return a Struts action if you're dealing
4968                            // with a regular HTTP servlet request, not a portlet HTTP servlet
4969                            // request.
4970    
4971                            return StringPool.BLANK;
4972                    }
4973    
4974                    return getPortletParam(request, "struts_action");
4975            }
4976    
4977            @Override
4978            public String[] getSystemGroups() {
4979                    return _allSystemGroups;
4980            }
4981    
4982            @Override
4983            public String[] getSystemOrganizationRoles() {
4984                    return _allSystemOrganizationRoles;
4985            }
4986    
4987            @Override
4988            public String[] getSystemRoles() {
4989                    return _allSystemRoles;
4990            }
4991    
4992            @Override
4993            public String[] getSystemSiteRoles() {
4994                    return _allSystemSiteRoles;
4995            }
4996    
4997            @Override
4998            public String getUniqueElementId(
4999                    HttpServletRequest request, String namespace, String elementId) {
5000    
5001                    String uniqueElementId = elementId;
5002    
5003                    Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
5004                            WebKeys.UNIQUE_ELEMENT_IDS);
5005    
5006                    if (uniqueElementIds == null) {
5007                            uniqueElementIds = new HashSet<String>();
5008    
5009                            request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
5010                    }
5011                    else {
5012                            int i = 1;
5013    
5014                            while (uniqueElementIds.contains(
5015                                                    namespace.concat(uniqueElementId))) {
5016    
5017                                    if (Validator.isNull(elementId) ||
5018                                            elementId.endsWith(StringPool.UNDERLINE)) {
5019    
5020                                            uniqueElementId = elementId.concat(String.valueOf(i));
5021                                    }
5022                                    else {
5023                                            uniqueElementId =
5024                                                    elementId.concat(StringPool.UNDERLINE).concat(
5025                                                            String.valueOf(i));
5026                                    }
5027    
5028                                    i++;
5029                            }
5030                    }
5031    
5032                    uniqueElementIds.add(namespace.concat(uniqueElementId));
5033    
5034                    return uniqueElementId;
5035            }
5036    
5037            @Override
5038            public String getUniqueElementId(
5039                    PortletRequest request, String namespace, String elementId) {
5040    
5041                    return getUniqueElementId(
5042                            getHttpServletRequest(request), namespace, elementId);
5043            }
5044    
5045            @Override
5046            public UploadPortletRequest getUploadPortletRequest(
5047                    PortletRequest portletRequest) {
5048    
5049                    PortletRequestImpl portletRequestImpl =
5050                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
5051    
5052                    DynamicServletRequest dynamicRequest =
5053                            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
5054    
5055                    HttpServletRequestWrapper requestWrapper =
5056                            (HttpServletRequestWrapper)dynamicRequest.getRequest();
5057    
5058                    UploadServletRequest uploadServletRequest = getUploadServletRequest(
5059                            requestWrapper);
5060    
5061                    return new UploadPortletRequestImpl(
5062                            uploadServletRequest,
5063                            getPortletNamespace(portletRequestImpl.getPortletName()));
5064            }
5065    
5066            @Override
5067            public UploadServletRequest getUploadServletRequest(
5068                    HttpServletRequest request) {
5069    
5070                    HttpServletRequestWrapper requestWrapper = null;
5071    
5072                    if (request instanceof HttpServletRequestWrapper) {
5073                            requestWrapper = (HttpServletRequestWrapper)request;
5074                    }
5075    
5076                    UploadServletRequest uploadServletRequest = null;
5077    
5078                    while (uploadServletRequest == null) {
5079    
5080                            // Find the underlying UploadServletRequest wrapper. For example,
5081                            // WebSphere wraps all requests with ProtectedServletRequest.
5082    
5083                            if (requestWrapper instanceof UploadServletRequest) {
5084                                    uploadServletRequest = (UploadServletRequest)requestWrapper;
5085                            }
5086                            else {
5087                                    HttpServletRequest parentRequest =
5088                                            (HttpServletRequest)requestWrapper.getRequest();
5089    
5090                                    if (!(parentRequest instanceof HttpServletRequestWrapper)) {
5091    
5092                                            // This block should never be reached unless this method is
5093                                            // called from a hot deployable portlet. See LayoutAction.
5094    
5095                                            if (ServerDetector.isWebLogic()) {
5096                                                    if (requestWrapper instanceof
5097                                                                    NonSerializableObjectRequestWrapper) {
5098    
5099                                                            parentRequest = requestWrapper;
5100                                                    }
5101                                                    else {
5102                                                            parentRequest =
5103                                                                    new NonSerializableObjectRequestWrapper(
5104                                                                            parentRequest);
5105                                                    }
5106                                            }
5107    
5108                                            uploadServletRequest = new UploadServletRequestImpl(
5109                                                    parentRequest);
5110    
5111                                            break;
5112                                    }
5113                                    else {
5114                                            requestWrapper = (HttpServletRequestWrapper)parentRequest;
5115                                    }
5116                            }
5117                    }
5118    
5119                    return uploadServletRequest;
5120            }
5121    
5122            @Override
5123            public Date getUptime() {
5124                    return _upTime;
5125            }
5126    
5127            @Override
5128            public String getURLWithSessionId(String url, String sessionId) {
5129                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5130                            return url;
5131                    }
5132    
5133                    if (Validator.isNull(url)) {
5134                            return url;
5135                    }
5136    
5137                    // LEP-4787
5138    
5139                    int x = url.indexOf(CharPool.SEMICOLON);
5140    
5141                    if (x != -1) {
5142                            return url;
5143                    }
5144    
5145                    x = url.indexOf(CharPool.QUESTION);
5146    
5147                    if (x != -1) {
5148                            StringBundler sb = new StringBundler(4);
5149    
5150                            sb.append(url.substring(0, x));
5151                            sb.append(_JSESSIONID);
5152                            sb.append(sessionId);
5153                            sb.append(url.substring(x));
5154    
5155                            return sb.toString();
5156                    }
5157    
5158                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
5159                    // http://www.abc.com/;jsessionid=XYZ does work.
5160    
5161                    x = url.indexOf(StringPool.DOUBLE_SLASH);
5162    
5163                    StringBundler sb = new StringBundler(4);
5164    
5165                    sb.append(url);
5166    
5167                    if (x != -1) {
5168                            int y = url.lastIndexOf(CharPool.SLASH);
5169    
5170                            if ((x + 1) == y) {
5171                                    sb.append(StringPool.SLASH);
5172                            }
5173                    }
5174    
5175                    sb.append(_JSESSIONID);
5176                    sb.append(sessionId);
5177    
5178                    return sb.toString();
5179            }
5180    
5181            @Override
5182            public User getUser(HttpServletRequest request)
5183                    throws PortalException, SystemException {
5184    
5185                    User user = (User)request.getAttribute(WebKeys.USER);
5186    
5187                    if (user != null) {
5188                            return user;
5189                    }
5190    
5191                    long userId = getUserId(request);
5192    
5193                    if (userId <= 0) {
5194    
5195                            // Portlet WARs may have the correct remote user and not have the
5196                            // correct user id because the user id is saved in the session and
5197                            // may not be accessible by the portlet WAR's session. This behavior
5198                            // is inconsistent across different application servers.
5199    
5200                            String remoteUser = request.getRemoteUser();
5201    
5202                            if (remoteUser == null) {
5203                                    return null;
5204                            }
5205    
5206                            userId = GetterUtil.getLong(remoteUser);
5207                    }
5208    
5209                    if (userId > 0) {
5210                            user = UserLocalServiceUtil.getUserById(userId);
5211    
5212                            request.setAttribute(WebKeys.USER, user);
5213                    }
5214    
5215                    return user;
5216            }
5217    
5218            @Override
5219            public User getUser(PortletRequest portletRequest)
5220                    throws PortalException, SystemException {
5221    
5222                    return getUser(getHttpServletRequest(portletRequest));
5223            }
5224    
5225            @Override
5226            public String getUserEmailAddress(long userId) throws SystemException {
5227                    try {
5228                            User user = UserLocalServiceUtil.getUserById(userId);
5229    
5230                            return user.getEmailAddress();
5231                    }
5232                    catch (PortalException pe) {
5233                            return StringPool.BLANK;
5234                    }
5235            }
5236    
5237            @Override
5238            public long getUserId(HttpServletRequest request) {
5239                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5240    
5241                    if (userIdObj != null) {
5242                            return userIdObj.longValue();
5243                    }
5244    
5245                    String path = GetterUtil.getString(request.getPathInfo());
5246                    String strutsAction = getStrutsAction(request);
5247                    String actionName = getPortletParam(request, "actionName");
5248    
5249                    boolean alwaysAllowDoAsUser = false;
5250    
5251                    if (path.equals("/portal/session_click") ||
5252                            strutsAction.equals("/document_library/edit_file_entry") ||
5253                            strutsAction.equals("/document_library_display/edit_file_entry") ||
5254                            strutsAction.equals("/image_gallery_display/edit_file_entry") ||
5255                            strutsAction.equals("/image_gallery_display/edit_image") ||
5256                            strutsAction.equals("/wiki/edit_page_attachment") ||
5257                            strutsAction.equals("/wiki_admin/edit_page_attachment") ||
5258                            strutsAction.equals("/wiki_display/edit_page_attachment") ||
5259                            actionName.equals("addFile")) {
5260    
5261                            try {
5262                                    alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5263                            }
5264                            catch (Exception e) {
5265                                    _log.error(e, e);
5266                            }
5267                    }
5268    
5269                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5270                             PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5271                            alwaysAllowDoAsUser) {
5272    
5273                            String doAsUserIdString = ParamUtil.getString(
5274                                    request, "doAsUserId");
5275    
5276                            try {
5277                                    long doAsUserId = getDoAsUserId(
5278                                            request, doAsUserIdString, alwaysAllowDoAsUser);
5279    
5280                                    if (doAsUserId > 0) {
5281                                            if (_log.isDebugEnabled()) {
5282                                                    _log.debug("Impersonating user " + doAsUserId);
5283                                            }
5284    
5285                                            return doAsUserId;
5286                                    }
5287                            }
5288                            catch (Exception e) {
5289                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
5290                            }
5291                    }
5292    
5293                    HttpSession session = request.getSession();
5294    
5295                    userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5296    
5297                    if (userIdObj != null) {
5298                            request.setAttribute(WebKeys.USER_ID, userIdObj);
5299    
5300                            return userIdObj.longValue();
5301                    }
5302                    else {
5303                            return 0;
5304                    }
5305            }
5306    
5307            @Override
5308            public long getUserId(PortletRequest portletRequest) {
5309                    return getUserId(getHttpServletRequest(portletRequest));
5310            }
5311    
5312            @Override
5313            public String getUserName(BaseModel<?> baseModel) {
5314                    long userId = 0;
5315                    String userName = StringPool.BLANK;
5316    
5317                    if (baseModel instanceof AuditedModel) {
5318                            AuditedModel auditedModel = (AuditedModel)baseModel;
5319    
5320                            userId = auditedModel.getUserId();
5321                            userName = auditedModel.getUserName();
5322                    }
5323                    else {
5324                            userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5325                            userName = BeanPropertiesUtil.getStringSilent(
5326                                    baseModel, "userName");
5327                    }
5328    
5329                    if (userId == 0) {
5330                            return StringPool.BLANK;
5331                    }
5332    
5333                    if (baseModel.isEscapedModel()) {
5334                            userName = HtmlUtil.unescape(userName);
5335                    }
5336    
5337                    userName = getUserName(userId, userName);
5338    
5339                    if (baseModel.isEscapedModel()) {
5340                            userName = HtmlUtil.escape(userName);
5341                    }
5342    
5343                    return userName;
5344            }
5345    
5346            @Override
5347            public String getUserName(long userId, String defaultUserName) {
5348                    return getUserName(
5349                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5350            }
5351    
5352            @Override
5353            public String getUserName(
5354                    long userId, String defaultUserName, HttpServletRequest request) {
5355    
5356                    return getUserName(
5357                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5358            }
5359    
5360            @Override
5361            public String getUserName(
5362                    long userId, String defaultUserName, String userAttribute) {
5363    
5364                    return getUserName(userId, defaultUserName, userAttribute, null);
5365            }
5366    
5367            @Override
5368            public String getUserName(
5369                    long userId, String defaultUserName, String userAttribute,
5370                    HttpServletRequest request) {
5371    
5372                    String userName = defaultUserName;
5373    
5374                    try {
5375                            User user = UserLocalServiceUtil.getUserById(userId);
5376    
5377                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5378                                    userName = user.getFullName();
5379                            }
5380                            else {
5381                                    userName = user.getScreenName();
5382                            }
5383    
5384                            if (request != null) {
5385                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5386    
5387                                    PortletURL portletURL = new PortletURLImpl(
5388                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
5389                                            PortletRequest.RENDER_PHASE);
5390    
5391                                    portletURL.setParameter(
5392                                            "struts_action", "/directory/view_user");
5393                                    portletURL.setParameter(
5394                                            "p_u_i_d", String.valueOf(user.getUserId()));
5395                                    portletURL.setPortletMode(PortletMode.VIEW);
5396                                    portletURL.setWindowState(WindowState.MAXIMIZED);
5397    
5398                                    userName =
5399                                            "<a href=\"" + portletURL.toString() + "\">" +
5400                                                    HtmlUtil.escape(userName) + "</a>";
5401                            }
5402                    }
5403                    catch (Exception e) {
5404                    }
5405    
5406                    return userName;
5407            }
5408    
5409            @Override
5410            public String getUserPassword(HttpServletRequest request) {
5411                    HttpSession session = request.getSession();
5412    
5413                    return getUserPassword(session);
5414            }
5415    
5416            @Override
5417            public String getUserPassword(HttpSession session) {
5418                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5419            }
5420    
5421            @Override
5422            public String getUserPassword(PortletRequest portletRequest) {
5423                    return getUserPassword(getHttpServletRequest(portletRequest));
5424            }
5425    
5426            @Override
5427            public String getUserValue(long userId, String param, String defaultValue)
5428                    throws SystemException {
5429    
5430                    if (Validator.isNotNull(defaultValue)) {
5431                            return defaultValue;
5432                    }
5433                    else {
5434                            try {
5435                                    User user = UserLocalServiceUtil.getUserById(userId);
5436    
5437                                    return BeanPropertiesUtil.getString(user, param, defaultValue);
5438                            }
5439                            catch (PortalException pe) {
5440                                    return StringPool.BLANK;
5441                            }
5442                    }
5443            }
5444    
5445            @Override
5446            public long getValidUserId(long companyId, long userId)
5447                    throws PortalException, SystemException {
5448    
5449                    User user = UserLocalServiceUtil.fetchUser(userId);
5450    
5451                    if (user == null) {
5452                            return UserLocalServiceUtil.getDefaultUserId(companyId);
5453                    }
5454    
5455                    if (user.getCompanyId() == companyId) {
5456                            return user.getUserId();
5457                    }
5458    
5459                    return userId;
5460            }
5461    
5462            @Override
5463            public String getVirtualLayoutActualURL(
5464                            long groupId, boolean privateLayout, String mainPath,
5465                            String friendlyURL, Map<String, String[]> params,
5466                            Map<String, Object> requestContext)
5467                    throws PortalException, SystemException {
5468    
5469                    // Group friendly URL
5470    
5471                    String groupFriendlyURL = null;
5472    
5473                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5474    
5475                    if (pos != -1) {
5476                            groupFriendlyURL = friendlyURL.substring(2, pos);
5477                    }
5478    
5479                    if (Validator.isNull(groupFriendlyURL)) {
5480                            return mainPath;
5481                    }
5482    
5483                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5484                            "request");
5485    
5486                    long companyId = PortalInstances.getCompanyId(request);
5487    
5488                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5489                            companyId, groupFriendlyURL);
5490    
5491                    if (group == null) {
5492                            return mainPath;
5493                    }
5494    
5495                    // Layout friendly URL
5496    
5497                    String layoutFriendlyURL = null;
5498    
5499                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5500                            layoutFriendlyURL = friendlyURL.substring(pos);
5501                    }
5502    
5503                    if (Validator.isNull(layoutFriendlyURL)) {
5504                            return mainPath;
5505                    }
5506    
5507                    String actualURL = getActualURL(
5508                            group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
5509                            params, requestContext);
5510    
5511                    return HttpUtil.addParameter(
5512                            HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
5513                            groupId);
5514            }
5515    
5516            @Override
5517            public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5518                            boolean privateLayout, String friendlyURL,
5519                            Map<String, String[]> params, Map<String, Object> requestContext)
5520                    throws PortalException, SystemException {
5521    
5522                    // Group friendly URL
5523    
5524                    String groupFriendlyURL = null;
5525    
5526                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5527    
5528                    if (pos != -1) {
5529                            groupFriendlyURL = friendlyURL.substring(2, pos);
5530                    }
5531    
5532                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5533                            "request");
5534    
5535                    long companyId = PortalInstances.getCompanyId(request);
5536    
5537                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5538                            companyId, groupFriendlyURL);
5539    
5540                    // Layout friendly URL
5541    
5542                    String layoutFriendlyURL = null;
5543    
5544                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5545                            layoutFriendlyURL = friendlyURL.substring(pos);
5546                    }
5547    
5548                    LayoutQueryStringComposite layoutQueryStringComposite =
5549                            getActualLayoutQueryStringComposite(
5550                                    group.getGroupId(), privateLayout, layoutFriendlyURL, params,
5551                                    requestContext);
5552    
5553                    return new LayoutFriendlyURLComposite(
5554                            layoutQueryStringComposite.getLayout(), layoutFriendlyURL);
5555            }
5556    
5557            @Override
5558            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5559                    throws PortalException, SystemException {
5560    
5561                    return getServletURL(
5562                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5563            }
5564    
5565            @Override
5566            public void initCustomSQL() {
5567                    _customSqlKeys = new String[] {
5568                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5569                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5570                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5571                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5572                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5573                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5574                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5575                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5576                                    "BOOKMARKSENTRY$]",
5577                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5578                                    "BOOKMARKSFOLDER$]",
5579                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5580                                    "DLFILEENTRY$]",
5581                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5582                                    "DLFOLDER$]",
5583                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.JOURNAL.MODEL." +
5584                                    "JOURNALFOLDER$]",
5585                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5586                                    "MBMESSAGE$]",
5587                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5588                                    "MBTHREAD$]",
5589                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
5590                            "[$PORTLET_PREFERENCES_PREFERENCES_DEFAULT$]",
5591                            "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5592                            "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5593                            "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5594                            "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5595                            "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5596                            "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5597                            "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5598                            "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5599                            "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5600                            "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5601                            "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5602                            "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5603                            "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5604                            "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5605                    };
5606    
5607                    DB db = DBFactoryUtil.getDB();
5608    
5609                    Object[] customSqlValues = new Object[] {
5610                            getClassNameId(Group.class), getClassNameId(Layout.class),
5611                            getClassNameId(Organization.class), getClassNameId(Role.class),
5612                            getClassNameId(User.class), getClassNameId(UserGroup.class),
5613                            getClassNameId(BlogsEntry.class),
5614                            getClassNameId(BookmarksEntry.class),
5615                            getClassNameId(BookmarksFolder.class),
5616                            getClassNameId(DLFileEntry.class), getClassNameId(DLFolder.class),
5617                            getClassNameId(JournalFolder.class),
5618                            getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
5619                            getClassNameId(WikiPage.class),
5620                            PortletConstants.DEFAULT_PREFERENCES,
5621                            ResourceConstants.SCOPE_COMPANY, ResourceConstants.SCOPE_GROUP,
5622                            ResourceConstants.SCOPE_GROUP_TEMPLATE,
5623                            ResourceConstants.SCOPE_INDIVIDUAL,
5624                            SocialRelationConstants.TYPE_BI_COWORKER,
5625                            SocialRelationConstants.TYPE_BI_FRIEND,
5626                            SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5627                            SocialRelationConstants.TYPE_BI_SIBLING,
5628                            SocialRelationConstants.TYPE_BI_SPOUSE,
5629                            SocialRelationConstants.TYPE_UNI_CHILD,
5630                            SocialRelationConstants.TYPE_UNI_ENEMY,
5631                            SocialRelationConstants.TYPE_UNI_FOLLOWER,
5632                            SocialRelationConstants.TYPE_UNI_PARENT,
5633                            SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5634                            SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5635                            db.getTemplateTrue()
5636                    };
5637    
5638                    _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5639            }
5640    
5641            @Override
5642            public User initUser(HttpServletRequest request) throws Exception {
5643                    User user = null;
5644    
5645                    try {
5646                            user = getUser(request);
5647                    }
5648                    catch (NoSuchUserException nsue) {
5649                            if (_log.isWarnEnabled()) {
5650                                    _log.warn(nsue.getMessage());
5651                            }
5652    
5653                            long userId = getUserId(request);
5654    
5655                            if (userId > 0) {
5656                                    HttpSession session = request.getSession();
5657    
5658                                    session.invalidate();
5659                            }
5660    
5661                            throw nsue;
5662                    }
5663    
5664                    if (user != null) {
5665                            return user;
5666                    }
5667    
5668                    Company company = getCompany(request);
5669    
5670                    return company.getDefaultUser();
5671            }
5672    
5673            @Override
5674            public void invokeTaglibDiscussion(
5675                            PortletConfig portletConfig, ActionRequest actionRequest,
5676                            ActionResponse actionResponse)
5677                    throws Exception {
5678    
5679                    _editDiscussionAction.processAction(
5680                            null, null, portletConfig, actionRequest, actionResponse);
5681            }
5682    
5683            /**
5684             * @deprecated As of 6.2.0 with no direct replacement
5685             */
5686            @Override
5687            public boolean isAllowAddPortletDefaultResource(
5688                            HttpServletRequest request, Portlet portlet)
5689                    throws PortalException, SystemException {
5690    
5691                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5692                            WebKeys.THEME_DISPLAY);
5693    
5694                    Layout layout = themeDisplay.getLayout();
5695                    LayoutTypePortlet layoutTypePortlet =
5696                            themeDisplay.getLayoutTypePortlet();
5697    
5698                    String portletId = portlet.getPortletId();
5699    
5700                    Boolean renderPortletResource = (Boolean)request.getAttribute(
5701                            WebKeys.RENDER_PORTLET_RESOURCE);
5702    
5703                    if (renderPortletResource != null) {
5704                            boolean runtimePortlet = renderPortletResource.booleanValue();
5705    
5706                            if (runtimePortlet) {
5707                                    return true;
5708                            }
5709                    }
5710    
5711                    if (layout.isTypePanel() &&
5712                            isPanelSelectedPortlet(themeDisplay, portletId)) {
5713    
5714                            return true;
5715                    }
5716    
5717                    if (layout.isTypeControlPanel() &&
5718                            isControlPanelPortlet(portletId, themeDisplay)) {
5719    
5720                            return true;
5721                    }
5722    
5723                    if ((layoutTypePortlet != null) &&
5724                            layoutTypePortlet.hasPortletId(portletId)) {
5725    
5726                            return true;
5727                    }
5728    
5729                    if (themeDisplay.isSignedIn() &&
5730                            portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
5731    
5732                            PermissionChecker permissionChecker =
5733                                    themeDisplay.getPermissionChecker();
5734    
5735                            Group group = layout.getGroup();
5736    
5737                            if (group.isSite()) {
5738                                    if (LayoutPermissionUtil.contains(
5739                                                    permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
5740                                            LayoutPermissionUtil.contains(
5741                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
5742    
5743                                            return true;
5744                                    }
5745                            }
5746    
5747                            if (group.isCompany()) {
5748                                    if (permissionChecker.isCompanyAdmin()) {
5749                                            return true;
5750                                    }
5751                            }
5752                            else if (group.isLayoutPrototype()) {
5753                                    long layoutPrototypeId = group.getClassPK();
5754    
5755                                    if (LayoutPrototypePermissionUtil.contains(
5756                                                    permissionChecker, layoutPrototypeId,
5757                                                    ActionKeys.UPDATE)) {
5758    
5759                                            return true;
5760                                    }
5761                            }
5762                            else if (group.isLayoutSetPrototype()) {
5763                                    long layoutSetPrototypeId = group.getClassPK();
5764    
5765                                    if (LayoutSetPrototypePermissionUtil.contains(
5766                                                    permissionChecker, layoutSetPrototypeId,
5767                                                    ActionKeys.UPDATE)) {
5768    
5769                                            return true;
5770                                    }
5771                            }
5772                            else if (group.isOrganization()) {
5773                                    long organizationId = group.getOrganizationId();
5774    
5775                                    if (OrganizationPermissionUtil.contains(
5776                                                    permissionChecker, organizationId, ActionKeys.UPDATE)) {
5777    
5778                                            return true;
5779                                    }
5780                            }
5781                            else if (group.isUserGroup()) {
5782                                    long scopeGroupId = themeDisplay.getScopeGroupId();
5783    
5784                                    if (GroupPermissionUtil.contains(
5785                                                    permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
5786    
5787                                            return true;
5788                                    }
5789                            }
5790                            else if (group.isUser()) {
5791                                    return true;
5792                            }
5793                    }
5794    
5795                    if (!portlet.isAddDefaultResource()) {
5796                            return false;
5797                    }
5798    
5799                    if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
5800                            return true;
5801                    }
5802    
5803                    Set<String> whiteList =
5804                            AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
5805    
5806                    if (whiteList.contains(portletId)) {
5807                            return true;
5808                    }
5809    
5810                    String namespace = getPortletNamespace(portletId);
5811    
5812                    String strutsAction = ParamUtil.getString(
5813                            request, namespace + "struts_action");
5814    
5815                    if (Validator.isNull(strutsAction)) {
5816                            strutsAction = ParamUtil.getString(request, "struts_action");
5817                    }
5818    
5819                    Set<String> whitelistActions =
5820                            AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
5821    
5822                    if (whitelistActions.contains(strutsAction)) {
5823                            return true;
5824                    }
5825    
5826                    String requestPortletAuthenticationToken = ParamUtil.getString(
5827                            request, "p_p_auth");
5828    
5829                    if (Validator.isNull(requestPortletAuthenticationToken)) {
5830                            HttpServletRequest originalRequest = getOriginalServletRequest(
5831                                    request);
5832    
5833                            requestPortletAuthenticationToken = ParamUtil.getString(
5834                                    originalRequest, "p_p_auth");
5835                    }
5836    
5837                    if (Validator.isNotNull(requestPortletAuthenticationToken)) {
5838                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
5839                                    request, layout.getPlid(), portletId);
5840    
5841                            if (requestPortletAuthenticationToken.equals(
5842                                            actualPortletAuthenticationToken)) {
5843    
5844                                    return true;
5845                            }
5846                    }
5847    
5848                    return false;
5849            }
5850    
5851            @Override
5852            public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
5853                    throws PortalException, SystemException {
5854    
5855                    Company company = getCompany(request);
5856    
5857                    return isCDNDynamicResourcesEnabled(company.getCompanyId());
5858            }
5859    
5860            @Override
5861            public boolean isCDNDynamicResourcesEnabled(long companyId) {
5862                    try {
5863                            return PrefsPropsUtil.getBoolean(
5864                                    companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
5865                                    PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
5866                    }
5867                    catch (SystemException se) {
5868                    }
5869    
5870                    return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
5871            }
5872    
5873            /**
5874             * @deprecated As of 6.1.0, renamed to {@link #isGroupAdmin(User, long)}
5875             */
5876            @Override
5877            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
5878                    return isGroupAdmin(user, groupId);
5879            }
5880    
5881            /**
5882             * @deprecated As of 6.1.0, renamed to {@link #isGroupOwner(User, long)}
5883             */
5884            @Override
5885            public boolean isCommunityOwner(User user, long groupId) throws Exception {
5886                    return isGroupOwner(user, groupId);
5887            }
5888    
5889            @Override
5890            public boolean isCompanyAdmin(User user) throws Exception {
5891                    PermissionChecker permissionChecker =
5892                            PermissionCheckerFactoryUtil.create(user);
5893    
5894                    return permissionChecker.isCompanyAdmin();
5895            }
5896    
5897            @Override
5898            public boolean isCompanyControlPanelPortlet(
5899                            String portletId, String category, ThemeDisplay themeDisplay)
5900                    throws PortalException, SystemException {
5901    
5902                    PermissionChecker permissionChecker =
5903                            themeDisplay.getPermissionChecker();
5904    
5905                    if (permissionChecker.isCompanyAdmin()) {
5906                            return true;
5907                    }
5908    
5909                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5910                            themeDisplay.getCompanyId());
5911    
5912                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5913    
5914                    return isControlPanelPortlet(portletId, category, themeDisplay);
5915            }
5916    
5917            @Override
5918            public boolean isCompanyControlPanelPortlet(
5919                            String portletId, ThemeDisplay themeDisplay)
5920                    throws PortalException, SystemException {
5921    
5922                    PermissionChecker permissionChecker =
5923                            themeDisplay.getPermissionChecker();
5924    
5925                    if (permissionChecker.isCompanyAdmin()) {
5926                            return true;
5927                    }
5928    
5929                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5930                            themeDisplay.getCompanyId());
5931    
5932                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5933    
5934                    return isControlPanelPortlet(portletId, themeDisplay);
5935            }
5936    
5937            @Override
5938            public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
5939                    throws PortalException, SystemException {
5940    
5941                    PermissionChecker permissionChecker =
5942                            themeDisplay.getPermissionChecker();
5943    
5944                    if (permissionChecker.isCompanyAdmin()) {
5945                            return true;
5946                    }
5947    
5948                    long scopeGroupId = themeDisplay.getScopeGroupId();
5949    
5950                    try {
5951                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5952                                    themeDisplay.getCompanyId());
5953    
5954                            themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5955    
5956                            List<Portlet> controlPanelPortlets = getControlPanelPortlets(
5957                                    PortletCategoryKeys.SITE_ADMINISTRATION, themeDisplay);
5958    
5959                            if (!controlPanelPortlets.isEmpty()) {
5960                                    return true;
5961                            }
5962                            else {
5963                                    return false;
5964                            }
5965                    }
5966                    finally {
5967                            themeDisplay.setScopeGroupId(scopeGroupId);
5968                    }
5969            }
5970    
5971            @Override
5972            public boolean isControlPanelPortlet(
5973                            String portletId, String category, ThemeDisplay themeDisplay)
5974                    throws SystemException {
5975    
5976                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
5977                            themeDisplay.getCompanyId(), portletId);
5978    
5979                    String controlPanelEntryCategory =
5980                            portlet.getControlPanelEntryCategory();
5981    
5982                    if (controlPanelEntryCategory.equals(category) ||
5983                            (category.endsWith(StringPool.PERIOD) &&
5984                             StringUtil.startsWith(controlPanelEntryCategory, category))) {
5985    
5986                            return isControlPanelPortlet(portletId, themeDisplay);
5987                    }
5988    
5989                    return false;
5990            }
5991    
5992            @Override
5993            public boolean isControlPanelPortlet(
5994                            String portletId, ThemeDisplay themeDisplay)
5995                    throws SystemException {
5996    
5997                    try {
5998                            return PortletPermissionUtil.hasControlPanelAccessPermission(
5999                                    themeDisplay.getPermissionChecker(),
6000                                    themeDisplay.getScopeGroupId(), portletId);
6001                    }
6002                    catch (PortalException pe) {
6003                            _log.warn("Unable to check control panel access permission", pe);
6004                    }
6005    
6006                    return false;
6007            }
6008    
6009            @Override
6010            public boolean isGroupAdmin(User user, long groupId) throws Exception {
6011                    PermissionChecker permissionChecker =
6012                            PermissionCheckerFactoryUtil.create(user);
6013    
6014                    return permissionChecker.isGroupAdmin(groupId);
6015            }
6016    
6017            @Override
6018            public boolean isGroupFriendlyURL(
6019                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6020    
6021                    if (fullURL.endsWith(groupFriendlyURL) &&
6022                            !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6023    
6024                            return true;
6025                    }
6026    
6027                    return false;
6028            }
6029    
6030            @Override
6031            public boolean isGroupOwner(User user, long groupId) throws Exception {
6032                    PermissionChecker permissionChecker =
6033                            PermissionCheckerFactoryUtil.create(user);
6034    
6035                    return permissionChecker.isGroupOwner(groupId);
6036            }
6037    
6038            @Override
6039            public boolean isLayoutDescendant(Layout layout, long layoutId)
6040                    throws PortalException, SystemException {
6041    
6042                    if (layout.getLayoutId() == layoutId) {
6043                            return true;
6044                    }
6045                    else {
6046                            for (Layout childLayout : layout.getChildren()) {
6047                                    if (isLayoutDescendant(childLayout, layoutId)) {
6048                                            return true;
6049                                    }
6050                            }
6051    
6052                            return false;
6053                    }
6054            }
6055    
6056            @Override
6057            public boolean isLayoutFirstPageable(Layout layout) {
6058                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6059    
6060                    return layoutSettings.isFirstPageable();
6061            }
6062    
6063            @Override
6064            public boolean isLayoutFirstPageable(String type) {
6065                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6066    
6067                    return layoutSettings.isFirstPageable();
6068            }
6069    
6070            @Override
6071            public boolean isLayoutFriendliable(Layout layout) {
6072                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6073    
6074                    return layoutSettings.isURLFriendliable();
6075            }
6076    
6077            @Override
6078            public boolean isLayoutFriendliable(String type) {
6079                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6080    
6081                    return layoutSettings.isURLFriendliable();
6082            }
6083    
6084            @Override
6085            public boolean isLayoutParentable(Layout layout) {
6086                    return isLayoutParentable(layout.getType());
6087            }
6088    
6089            @Override
6090            public boolean isLayoutParentable(String type) {
6091                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6092    
6093                    return layoutSettings.isParentable();
6094            }
6095    
6096            @Override
6097            public boolean isLayoutSitemapable(Layout layout) {
6098                    if (layout.isPrivateLayout()) {
6099                            return false;
6100                    }
6101    
6102                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6103    
6104                    return layoutSettings.isSitemapable();
6105            }
6106    
6107            @Override
6108            public boolean isMethodGet(PortletRequest portletRequest) {
6109                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6110    
6111                    String method = GetterUtil.getString(request.getMethod());
6112    
6113                    if (method.equalsIgnoreCase(HttpMethods.GET)) {
6114                            return true;
6115                    }
6116                    else {
6117                            return false;
6118                    }
6119            }
6120    
6121            @Override
6122            public boolean isMethodPost(PortletRequest portletRequest) {
6123                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6124    
6125                    String method = GetterUtil.getString(request.getMethod());
6126    
6127                    if (method.equalsIgnoreCase(HttpMethods.POST)) {
6128                            return true;
6129                    }
6130                    else {
6131                            return false;
6132                    }
6133            }
6134    
6135            @Override
6136            public boolean isMultipartRequest(HttpServletRequest request) {
6137                    String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6138    
6139                    if ((contentType != null) &&
6140                            contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6141    
6142                            return true;
6143                    }
6144                    else {
6145                            return false;
6146                    }
6147            }
6148    
6149            @Override
6150            public boolean isOmniadmin(long userId) {
6151                    return OmniadminUtil.isOmniadmin(userId);
6152            }
6153    
6154            @Override
6155            public boolean isReservedParameter(String name) {
6156                    return _reservedParams.contains(name);
6157            }
6158    
6159            @Override
6160            public boolean isRSSFeedsEnabled() {
6161                    return PropsValues.RSS_FEEDS_ENABLED;
6162            }
6163    
6164            @Override
6165            public boolean isSecure(HttpServletRequest request) {
6166                    HttpSession session = request.getSession();
6167    
6168                    if (session == null) {
6169                            return request.isSecure();
6170                    }
6171    
6172                    Boolean httpsInitial = (Boolean)session.getAttribute(
6173                            WebKeys.HTTPS_INITIAL);
6174    
6175                    boolean secure = false;
6176    
6177                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6178                            !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6179                            (httpsInitial != null) && !httpsInitial.booleanValue()) {
6180    
6181                            secure = false;
6182                    }
6183                    else {
6184                            secure = request.isSecure();
6185                    }
6186    
6187                    return secure;
6188            }
6189    
6190            @Override
6191            public boolean isSystemGroup(String groupName) {
6192                    if (groupName == null) {
6193                            return false;
6194                    }
6195    
6196                    groupName = groupName.trim();
6197    
6198                    int pos = Arrays.binarySearch(
6199                            _sortedSystemGroups, groupName, new StringComparator());
6200    
6201                    if (pos >= 0) {
6202                            return true;
6203                    }
6204                    else {
6205                            return false;
6206                    }
6207            }
6208    
6209            @Override
6210            public boolean isSystemRole(String roleName) {
6211                    if (roleName == null) {
6212                            return false;
6213                    }
6214    
6215                    roleName = roleName.trim();
6216    
6217                    int pos = Arrays.binarySearch(
6218                            _sortedSystemRoles, roleName, new StringComparator());
6219    
6220                    if (pos >= 0) {
6221                            return true;
6222                    }
6223                    else {
6224                            pos = Arrays.binarySearch(
6225                                    _sortedSystemSiteRoles, roleName, new StringComparator());
6226    
6227                            if (pos >= 0) {
6228                                    return true;
6229                            }
6230                            else {
6231                                    pos = Arrays.binarySearch(
6232                                            _sortedSystemOrganizationRoles, roleName,
6233                                            new StringComparator());
6234    
6235                                    if (pos >= 0) {
6236                                            return true;
6237                                    }
6238                            }
6239                    }
6240    
6241                    return false;
6242            }
6243    
6244            @Override
6245            public boolean isUpdateAvailable() throws SystemException {
6246                    return PluginPackageUtil.isUpdateAvailable();
6247            }
6248    
6249            @Override
6250            public boolean isValidResourceId(String resourceId) {
6251                    if (Validator.isNull(resourceId)) {
6252                            return true;
6253                    }
6254    
6255                    Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6256    
6257                    if (matcher.matches()) {
6258                            return false;
6259                    }
6260    
6261                    return true;
6262            }
6263    
6264            @Override
6265            public void removePortalPortEventListener(
6266                    PortalPortEventListener portalPortEventListener) {
6267    
6268                    _portalPortEventListeners.remove(portalPortEventListener);
6269            }
6270    
6271            @Override
6272            public void resetCDNHosts() {
6273                    _cdnHostHttpMap.clear();
6274                    _cdnHostHttpsMap.clear();
6275    
6276                    if (!ClusterInvokeThreadLocal.isEnabled()) {
6277                            return;
6278                    }
6279    
6280                    ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6281                            _resetCDNHostsMethodHandler, true);
6282    
6283                    try {
6284                            ClusterExecutorUtil.execute(clusterRequest);
6285                    }
6286                    catch (Exception e) {
6287                            _log.error("Unable to clear cluster wide CDN hosts", e);
6288                    }
6289            }
6290    
6291            /**
6292             * @deprecated As of 6.2.0, replaced by {@link
6293             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelist}
6294             */
6295            @Override
6296            public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6297                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6298            }
6299    
6300            /**
6301             * @deprecated As of 6.2.0, replaced by {@link
6302             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelistActions}
6303             */
6304            @Override
6305            public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6306                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6307            }
6308    
6309            @Override
6310            public void sendError(
6311                            Exception e, ActionRequest actionRequest,
6312                            ActionResponse actionResponse)
6313                    throws IOException {
6314    
6315                    sendError(0, e, actionRequest, actionResponse);
6316            }
6317    
6318            @Override
6319            public void sendError(
6320                            Exception e, HttpServletRequest request,
6321                            HttpServletResponse response)
6322                    throws IOException, ServletException {
6323    
6324                    sendError(0, e, request, response);
6325            }
6326    
6327            @Override
6328            public void sendError(
6329                            int status, Exception e, ActionRequest actionRequest,
6330                            ActionResponse actionResponse)
6331                    throws IOException {
6332    
6333                    StringBundler sb = new StringBundler(7);
6334    
6335                    sb.append(_pathMain);
6336                    sb.append("/portal/status?status=");
6337                    sb.append(status);
6338                    sb.append("&exception=");
6339                    sb.append(e.getClass().getName());
6340                    sb.append("&previousURL=");
6341                    sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6342    
6343                    actionResponse.sendRedirect(sb.toString());
6344            }
6345    
6346            @Override
6347            public void sendError(
6348                            int status, Exception e, HttpServletRequest request,
6349                            HttpServletResponse response)
6350                    throws IOException, ServletException {
6351    
6352                    if (_log.isDebugEnabled()) {
6353                            String currentURL = (String)request.getAttribute(
6354                                    WebKeys.CURRENT_URL);
6355    
6356                            _log.debug(
6357                                    "Current URL " + currentURL + " generates exception: " +
6358                                            e.getMessage());
6359                    }
6360    
6361                    if (e instanceof NoSuchImageException) {
6362                            if (_logWebServerServlet.isWarnEnabled()) {
6363                                    _logWebServerServlet.warn(e, e);
6364                            }
6365                    }
6366                    else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6367                            if ((e instanceof NoSuchLayoutException) ||
6368                                    (e instanceof PrincipalException)) {
6369    
6370                                    String msg = e.getMessage();
6371    
6372                                    if (Validator.isNotNull(msg)) {
6373                                            _log.debug(msg);
6374                                    }
6375                            }
6376                            else {
6377                                    _log.debug(e, e);
6378                            }
6379                    }
6380                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6381                            _log.warn(e, e);
6382                    }
6383    
6384                    if (response.isCommitted()) {
6385                            return;
6386                    }
6387    
6388                    if (status == 0) {
6389                            if (e instanceof PrincipalException) {
6390                                    status = HttpServletResponse.SC_FORBIDDEN;
6391                            }
6392                            else {
6393                                    String name = e.getClass().getName();
6394    
6395                                    name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6396    
6397                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6398                                            status = HttpServletResponse.SC_NOT_FOUND;
6399                                    }
6400                            }
6401    
6402                            if (status == 0) {
6403    
6404                                    // LPS-5352
6405    
6406                                    if (PropsValues.TCK_URL) {
6407                                            status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
6408                                    }
6409                                    else {
6410                                            status = HttpServletResponse.SC_BAD_REQUEST;
6411                                    }
6412                            }
6413                    }
6414    
6415                    HttpSession session = PortalSessionThreadLocal.getHttpSession();
6416    
6417                    if (session == null) {
6418                            session = request.getSession();
6419                    }
6420    
6421                    ServletContext servletContext = session.getServletContext();
6422    
6423                    String redirect = PATH_MAIN + "/portal/status";
6424    
6425                    if ((e instanceof NoSuchLayoutException) &&
6426                            Validator.isNotNull(
6427                                    PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6428    
6429                            response.setStatus(status);
6430    
6431                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6432    
6433                            RequestDispatcher requestDispatcher =
6434                                    servletContext.getRequestDispatcher(redirect);
6435    
6436                            if (requestDispatcher != null) {
6437                                    requestDispatcher.forward(request, response);
6438                            }
6439                    }
6440                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6441                            response.setStatus(status);
6442    
6443                            SessionErrors.add(session, e.getClass(), e);
6444    
6445                            RequestDispatcher requestDispatcher =
6446                                    servletContext.getRequestDispatcher(redirect);
6447    
6448                            if (requestDispatcher != null) {
6449                                    requestDispatcher.forward(request, response);
6450                            }
6451                    }
6452                    else {
6453                            if (e != null) {
6454                                    response.sendError(status, e.getMessage());
6455                            }
6456                            else {
6457                                    response.sendError(status);
6458                            }
6459                    }
6460            }
6461    
6462            @Override
6463            public void sendRSSFeedsDisabledError(
6464                            HttpServletRequest request, HttpServletResponse response)
6465                    throws IOException, ServletException {
6466    
6467                    sendError(
6468                            HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
6469                            request, response);
6470            }
6471    
6472            @Override
6473            public void sendRSSFeedsDisabledError(
6474                            PortletRequest portletRequest, PortletResponse portletResponse)
6475                    throws IOException, ServletException {
6476    
6477                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6478                    HttpServletResponse response = getHttpServletResponse(portletResponse);
6479    
6480                    sendRSSFeedsDisabledError(request, response);
6481            }
6482    
6483            @Override
6484            public void setPageDescription(
6485                    String description, HttpServletRequest request) {
6486    
6487                    ListMergeable<String> descriptionListMergeable =
6488                            new ListMergeable<String>();
6489    
6490                    descriptionListMergeable.add(description);
6491    
6492                    request.setAttribute(
6493                            WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6494            }
6495    
6496            @Override
6497            public void setPageKeywords(String keywords, HttpServletRequest request) {
6498                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6499    
6500                    addPageKeywords(keywords, request);
6501            }
6502    
6503            @Override
6504            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6505                    ListMergeable<String> subtitleListMergeable =
6506                            new ListMergeable<String>();
6507    
6508                    subtitleListMergeable.add(subtitle);
6509    
6510                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6511            }
6512    
6513            @Override
6514            public void setPageTitle(String title, HttpServletRequest request) {
6515                    ListMergeable<String> titleListMergeable = new ListMergeable<String>();
6516    
6517                    titleListMergeable.add(title);
6518    
6519                    request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6520            }
6521    
6522            @Override
6523            public void setPortalPort(HttpServletRequest request) {
6524                    if (request.isSecure()) {
6525                            if (_securePortalPort.get() == -1) {
6526                                    int securePortalPort = request.getServerPort();
6527    
6528                                    _securePortalPort.compareAndSet(-1, securePortalPort);
6529                            }
6530                    }
6531                    else {
6532                            if (_portalPort.get() == -1) {
6533                                    int portalPort = request.getServerPort();
6534    
6535                                    if (_portalPort.compareAndSet(-1, portalPort)) {
6536                                            notifyPortalPortEventListeners(portalPort);
6537                                    }
6538                            }
6539                    }
6540            }
6541    
6542            @Override
6543            public void storePreferences(PortletPreferences portletPreferences)
6544                    throws IOException, ValidatorException {
6545    
6546                    PortletPreferencesWrapper portletPreferencesWrapper =
6547                            (PortletPreferencesWrapper)portletPreferences;
6548    
6549                    PortletPreferencesImpl portletPreferencesImpl =
6550                            portletPreferencesWrapper.getPortletPreferencesImpl();
6551    
6552                    portletPreferencesImpl.store();
6553            }
6554    
6555            @Override
6556            public String[] stripURLAnchor(String url, String separator) {
6557                    String anchor = StringPool.BLANK;
6558    
6559                    int pos = url.indexOf(separator);
6560    
6561                    if (pos != -1) {
6562                            anchor = url.substring(pos);
6563                            url = url.substring(0, pos);
6564                    }
6565    
6566                    return new String[] {url, anchor};
6567            }
6568    
6569            @Override
6570            public String transformCustomSQL(String sql) {
6571                    if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6572                            initCustomSQL();
6573                    }
6574    
6575                    return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6576            }
6577    
6578            @Override
6579            public String transformSQL(String sql) {
6580                    return SQLTransformer.transform(sql);
6581            }
6582    
6583            @Override
6584            public PortletMode updatePortletMode(
6585                    String portletId, User user, Layout layout, PortletMode portletMode,
6586                    HttpServletRequest request) {
6587    
6588                    LayoutTypePortlet layoutType =
6589                            (LayoutTypePortlet)layout.getLayoutType();
6590    
6591                    if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
6592                            if (layoutType.hasModeAboutPortletId(portletId)) {
6593                                    return LiferayPortletMode.ABOUT;
6594                            }
6595                            else if (layoutType.hasModeConfigPortletId(portletId)) {
6596                                    return LiferayPortletMode.CONFIG;
6597                            }
6598                            else if (layoutType.hasModeEditPortletId(portletId)) {
6599                                    return PortletMode.EDIT;
6600                            }
6601                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
6602                                    return LiferayPortletMode.EDIT_DEFAULTS;
6603                            }
6604                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
6605                                    return LiferayPortletMode.EDIT_GUEST;
6606                            }
6607                            else if (layoutType.hasModeHelpPortletId(portletId)) {
6608                                    return PortletMode.HELP;
6609                            }
6610                            else if (layoutType.hasModePreviewPortletId(portletId)) {
6611                                    return LiferayPortletMode.PREVIEW;
6612                            }
6613                            else if (layoutType.hasModePrintPortletId(portletId)) {
6614                                    return LiferayPortletMode.PRINT;
6615                            }
6616                            else {
6617                                    return PortletMode.VIEW;
6618                            }
6619                    }
6620                    else {
6621                            boolean updateLayout = false;
6622    
6623                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
6624                                    !layoutType.hasModeAboutPortletId(portletId)) {
6625    
6626                                    layoutType.addModeAboutPortletId(portletId);
6627    
6628                                    updateLayout = true;
6629                            }
6630                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
6631                                             !layoutType.hasModeConfigPortletId(portletId)) {
6632    
6633                                    layoutType.addModeConfigPortletId(portletId);
6634    
6635                                    updateLayout = true;
6636                            }
6637                            else if (portletMode.equals(PortletMode.EDIT) &&
6638                                             !layoutType.hasModeEditPortletId(portletId)) {
6639    
6640                                    layoutType.addModeEditPortletId(portletId);
6641    
6642                                    updateLayout = true;
6643                            }
6644                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
6645                                             !layoutType.hasModeEditDefaultsPortletId(portletId)) {
6646    
6647                                    layoutType.addModeEditDefaultsPortletId(portletId);
6648    
6649                                    updateLayout = true;
6650                            }
6651                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
6652                                             !layoutType.hasModeEditGuestPortletId(portletId)) {
6653    
6654                                    layoutType.addModeEditGuestPortletId(portletId);
6655    
6656                                    updateLayout = true;
6657                            }
6658                            else if (portletMode.equals(PortletMode.HELP) &&
6659                                             !layoutType.hasModeHelpPortletId(portletId)) {
6660    
6661                                    layoutType.addModeHelpPortletId(portletId);
6662    
6663                                    updateLayout = true;
6664                            }
6665                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
6666                                             !layoutType.hasModePreviewPortletId(portletId)) {
6667    
6668                                    layoutType.addModePreviewPortletId(portletId);
6669    
6670                                    updateLayout = true;
6671                            }
6672                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
6673                                             !layoutType.hasModePrintPortletId(portletId)) {
6674    
6675                                    layoutType.addModePrintPortletId(portletId);
6676    
6677                                    updateLayout = true;
6678                            }
6679                            else if (portletMode.equals(PortletMode.VIEW) &&
6680                                             !layoutType.hasModeViewPortletId(portletId)) {
6681    
6682                                    layoutType.removeModesPortletId(portletId);
6683    
6684                                    updateLayout = true;
6685                            }
6686    
6687                            if (updateLayout) {
6688                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6689    
6690                                    if (layoutClone != null) {
6691                                            layoutClone.update(
6692                                                    request, layout.getPlid(), layout.getTypeSettings());
6693                                    }
6694                            }
6695    
6696                            return portletMode;
6697                    }
6698            }
6699    
6700            @Override
6701            public String updateRedirect(
6702                    String redirect, String oldPath, String newPath) {
6703    
6704                    if (Validator.isNull(redirect) || (oldPath == null) ||
6705                            oldPath.equals(newPath)) {
6706    
6707                            return redirect;
6708                    }
6709    
6710                    String queryString = HttpUtil.getQueryString(redirect);
6711    
6712                    String redirectParam = HttpUtil.getParameter(
6713                            redirect, "redirect", false);
6714    
6715                    if (Validator.isNotNull(redirectParam)) {
6716                            String newRedirectParam = StringUtil.replace(
6717                                    redirectParam, HttpUtil.encodeURL(oldPath),
6718                                    HttpUtil.encodeURL(newPath));
6719    
6720                            queryString = StringUtil.replace(
6721                                    queryString, redirectParam, newRedirectParam);
6722                    }
6723    
6724                    String redirectPath = HttpUtil.getPath(redirect);
6725    
6726                    int pos = redirect.indexOf(redirectPath);
6727    
6728                    String prefix = redirect.substring(0, pos);
6729    
6730                    pos = redirectPath.lastIndexOf(oldPath);
6731    
6732                    if (pos != -1) {
6733                            prefix += redirectPath.substring(0, pos);
6734    
6735                            String suffix = redirectPath.substring(pos + oldPath.length());
6736    
6737                            redirect = prefix + newPath + suffix;
6738                    }
6739                    else {
6740                            redirect = prefix + redirectPath;
6741                    }
6742    
6743                    if (Validator.isNotNull(queryString)) {
6744                            redirect += StringPool.QUESTION + queryString;
6745                    }
6746    
6747                    return redirect;
6748            }
6749    
6750            @Override
6751            public WindowState updateWindowState(
6752                    String portletId, User user, Layout layout, WindowState windowState,
6753                    HttpServletRequest request) {
6754    
6755                    LayoutTypePortlet layoutType =
6756                            (LayoutTypePortlet)layout.getLayoutType();
6757    
6758                    if ((windowState == null) || Validator.isNull(windowState.toString())) {
6759                            if (layoutType.hasStateMaxPortletId(portletId)) {
6760                                    windowState = WindowState.MAXIMIZED;
6761                            }
6762                            else if (layoutType.hasStateMinPortletId(portletId)) {
6763                                    windowState = WindowState.MINIMIZED;
6764                            }
6765                            else {
6766                                    windowState = WindowState.NORMAL;
6767                            }
6768                    }
6769                    else {
6770                            boolean updateLayout = false;
6771    
6772                            if (windowState.equals(WindowState.MAXIMIZED) &&
6773                                    !layoutType.hasStateMaxPortletId(portletId)) {
6774    
6775                                    layoutType.addStateMaxPortletId(portletId);
6776    
6777                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
6778                                            updateLayout = true;
6779                                    }
6780                            }
6781                            else if (windowState.equals(WindowState.MINIMIZED) &&
6782                                             !layoutType.hasStateMinPortletId(portletId)) {
6783    
6784                                    layoutType.addStateMinPortletId(portletId);
6785    
6786                                    updateLayout = true;
6787                            }
6788                            else if (windowState.equals(WindowState.NORMAL) &&
6789                                             !layoutType.hasStateNormalPortletId(portletId)) {
6790    
6791                                    layoutType.removeStatesPortletId(portletId);
6792    
6793                                    updateLayout = true;
6794                            }
6795    
6796                            if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
6797                                    portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
6798    
6799                                    updateLayout = false;
6800                            }
6801    
6802                            if (updateLayout) {
6803                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6804    
6805                                    if (layoutClone != null) {
6806                                            layoutClone.update(
6807                                                    request, layout.getPlid(), layout.getTypeSettings());
6808                                    }
6809                            }
6810                    }
6811    
6812                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6813                            WebKeys.THEME_DISPLAY);
6814    
6815                    themeDisplay.setStateExclusive(
6816                            windowState.equals(LiferayWindowState.EXCLUSIVE));
6817                    themeDisplay.setStateMaximized(
6818                            windowState.equals(WindowState.MAXIMIZED));
6819                    themeDisplay.setStatePopUp(
6820                            windowState.equals(LiferayWindowState.POP_UP));
6821    
6822                    if (themeDisplay.isStateMaximized() &&
6823                            themeDisplay.isShowAddContentIcon()) {
6824    
6825                            themeDisplay.setShowAddContentIcon(false);
6826                    }
6827                    else if (!themeDisplay.isStateMaximized() &&
6828                                     !themeDisplay.isShowAddContentIcon() &&
6829                                     themeDisplay.isShowAddContentIconPermission()) {
6830    
6831                            themeDisplay.setShowAddContentIcon(true);
6832                    }
6833    
6834                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
6835    
6836                    return windowState;
6837            }
6838    
6839            protected void addDefaultResource(
6840                            long companyId, Layout layout, Portlet portlet,
6841                            boolean portletActions)
6842                    throws PortalException, SystemException {
6843    
6844                    long groupId = getScopeGroupId(layout, portlet.getPortletId());
6845    
6846                    addDefaultResource(companyId, groupId, layout, portlet, portletActions);
6847            }
6848    
6849            protected void addDefaultResource(
6850                            long companyId, long groupId, Layout layout, Portlet portlet,
6851                            boolean portletActions)
6852                    throws PortalException, SystemException {
6853    
6854                    String rootPortletId = portlet.getRootPortletId();
6855    
6856                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
6857                            layout.getPlid(), portlet.getPortletId());
6858    
6859                    String name = null;
6860                    String primaryKey = null;
6861    
6862                    if (portletActions) {
6863                            name = rootPortletId;
6864                            primaryKey = portletPrimaryKey;
6865                    }
6866                    else {
6867                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
6868                            primaryKey = String.valueOf(groupId);
6869                    }
6870    
6871                    if (Validator.isNull(name)) {
6872                            return;
6873                    }
6874    
6875                    int count =
6876                            ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
6877                                    companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
6878                                    primaryKey);
6879    
6880                    if (count > 0) {
6881                            return;
6882                    }
6883    
6884                    boolean addGuestPermissions = true;
6885    
6886                    if (portletActions) {
6887                            Group layoutGroup = layout.getGroup();
6888    
6889                            if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype()) {
6890                                    addGuestPermissions = false;
6891                            }
6892                    }
6893    
6894                    ResourceLocalServiceUtil.addResources(
6895                            companyId, groupId, 0, name, primaryKey, portletActions, true,
6896                            addGuestPermissions);
6897            }
6898    
6899            protected String buildI18NPath(Locale locale) {
6900                    String languageId = LocaleUtil.toLanguageId(locale);
6901    
6902                    if (Validator.isNull(languageId)) {
6903                            return null;
6904                    }
6905    
6906                    if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
6907                            Locale priorityLocale = LanguageUtil.getLocale(
6908                                    locale.getLanguage());
6909    
6910                            if (locale.equals(priorityLocale)) {
6911                                    languageId = locale.getLanguage();
6912                            }
6913                    }
6914                    else {
6915                            languageId = locale.getLanguage();
6916                    }
6917    
6918                    return StringPool.SLASH.concat(languageId);
6919            }
6920    
6921            protected long doGetPlidFromPortletId(
6922                            long groupId, boolean privateLayout, String portletId)
6923                    throws PortalException, SystemException {
6924    
6925                    long scopeGroupId = groupId;
6926    
6927                    try {
6928                            Group group = GroupLocalServiceUtil.getGroup(groupId);
6929    
6930                            if (group.isLayout()) {
6931                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
6932                                            group.getClassPK());
6933    
6934                                    groupId = scopeLayout.getGroupId();
6935                            }
6936                    }
6937                    catch (Exception e) {
6938                    }
6939    
6940                    long plid = LayoutConstants.DEFAULT_PLID;
6941    
6942                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
6943                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
6944    
6945                    for (Layout layout : layouts) {
6946                            LayoutTypePortlet layoutTypePortlet =
6947                                    (LayoutTypePortlet)layout.getLayoutType();
6948    
6949                            if (layoutTypePortlet.hasPortletId(portletId)) {
6950                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
6951                                            plid = layout.getPlid();
6952    
6953                                            break;
6954                                    }
6955                            }
6956                    }
6957    
6958                    return plid;
6959            }
6960    
6961            protected List<Portlet> filterControlPanelPortlets(
6962                    Set<Portlet> portlets, ThemeDisplay themeDisplay) {
6963    
6964                    List<Portlet> filteredPortlets = new ArrayList<Portlet>(portlets);
6965    
6966                    Iterator<Portlet> itr = filteredPortlets.iterator();
6967    
6968                    while (itr.hasNext()) {
6969                            Portlet portlet = itr.next();
6970    
6971                            try {
6972                                    if (!portlet.isActive() || portlet.isInstanceable() ||
6973                                            !PortletPermissionUtil.hasControlPanelAccessPermission(
6974                                                    themeDisplay.getPermissionChecker(),
6975                                                    themeDisplay.getScopeGroupId(), portlet)) {
6976    
6977                                            itr.remove();
6978                                    }
6979                            }
6980                            catch (Exception e) {
6981                                    _log.error(e, e);
6982    
6983                                    itr.remove();
6984                            }
6985                    }
6986    
6987                    return filteredPortlets;
6988            }
6989    
6990            protected Locale getAvailableLocale(long groupId, Locale locale) {
6991                    if (Validator.isNull(locale.getCountry())) {
6992    
6993                            // Locales must contain a country code
6994    
6995                            locale = LanguageUtil.getLocale(locale.getLanguage());
6996                    }
6997    
6998                    if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
6999                            return null;
7000                    }
7001    
7002                    return locale;
7003            }
7004    
7005            protected Map<String, List<Portlet>> getCategoriesMap(
7006                            HttpServletRequest request, String attributeName,
7007                            String[] categories)
7008                    throws SystemException {
7009    
7010                    Map<String, List<Portlet>> categoriesMap =
7011                            (Map<String, List<Portlet>>)request.getAttribute(attributeName);
7012    
7013                    if (categoriesMap != null) {
7014                            return categoriesMap;
7015                    }
7016    
7017                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7018                            WebKeys.THEME_DISPLAY);
7019    
7020                    categoriesMap = new LinkedHashMap<String, List<Portlet>>();
7021    
7022                    for (String category : categories) {
7023                            List<Portlet> portlets = getControlPanelPortlets(
7024                                    category, themeDisplay);
7025    
7026                            if (!portlets.isEmpty()) {
7027                                    categoriesMap.put(category, portlets);
7028                            }
7029                    }
7030    
7031                    request.setAttribute(attributeName, categoriesMap);
7032    
7033                    return categoriesMap;
7034            }
7035    
7036            protected long getDefaultScopeGroupId(long companyId)
7037                    throws PortalException, SystemException {
7038    
7039                    long doAsGroupId = 0;
7040    
7041                    Collection<Portlet> portlets = getControlPanelPortlets(
7042                            companyId, PortletCategoryKeys.SITE_ADMINISTRATION);
7043    
7044                    List<Group> groups = GroupServiceUtil.getManageableSiteGroups(
7045                            portlets, 1);
7046    
7047                    if (!groups.isEmpty()) {
7048                            Group group = groups.get(0);
7049    
7050                            doAsGroupId = group.getGroupId();
7051                    }
7052                    else {
7053                            Group guestGroup = GroupLocalServiceUtil.fetchGroup(
7054                                    companyId, GroupConstants.GUEST);
7055    
7056                            if (guestGroup != null) {
7057                                    doAsGroupId = guestGroup.getGroupId();
7058                            }
7059                    }
7060    
7061                    return doAsGroupId;
7062            }
7063    
7064            protected long getDoAsUserId(
7065                            HttpServletRequest request, String doAsUserIdString,
7066                            boolean alwaysAllowDoAsUser)
7067                    throws Exception {
7068    
7069                    if (Validator.isNull(doAsUserIdString)) {
7070                            return 0;
7071                    }
7072    
7073                    long doAsUserId = 0;
7074    
7075                    try {
7076                            Company company = getCompany(request);
7077    
7078                            doAsUserId = GetterUtil.getLong(
7079                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7080                    }
7081                    catch (Exception e) {
7082                            if (_log.isWarnEnabled()) {
7083                                    _log.warn(
7084                                            "Unable to impersonate " + doAsUserIdString +
7085                                                    " because the string cannot be decrypted");
7086                            }
7087    
7088                            return 0;
7089                    }
7090    
7091                    if (_log.isDebugEnabled()) {
7092                            if (alwaysAllowDoAsUser) {
7093                                    _log.debug(
7094                                            "doAsUserId path or Struts action is always allowed");
7095                            }
7096                            else {
7097                                    _log.debug(
7098                                            "doAsUserId path is Struts action not always allowed");
7099                            }
7100                    }
7101    
7102                    if (alwaysAllowDoAsUser) {
7103                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7104    
7105                            return doAsUserId;
7106                    }
7107    
7108                    HttpSession session = request.getSession();
7109    
7110                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7111    
7112                    if (realUserIdObj == null) {
7113                            return 0;
7114                    }
7115    
7116                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7117    
7118                    long[] organizationIds = doAsUser.getOrganizationIds();
7119    
7120                    User realUser = UserLocalServiceUtil.getUserById(
7121                            realUserIdObj.longValue());
7122    
7123                    PermissionChecker permissionChecker =
7124                            PermissionCheckerFactoryUtil.create(realUser);
7125    
7126                    if (doAsUser.isDefaultUser() ||
7127                            UserPermissionUtil.contains(
7128                                    permissionChecker, doAsUserId, organizationIds,
7129                                    ActionKeys.IMPERSONATE)) {
7130    
7131                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7132    
7133                            return doAsUserId;
7134                    }
7135                    else {
7136                            _log.error(
7137                                    "User " + realUserIdObj + " does not have the permission " +
7138                                            "to impersonate " + doAsUserId);
7139    
7140                            return 0;
7141                    }
7142            }
7143    
7144            protected String getGroupFriendlyURL(
7145                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
7146                            boolean canonicalURL)
7147                    throws PortalException, SystemException {
7148    
7149                    LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7150                            group.getGroupId(), privateLayoutSet);
7151    
7152                    String portalURL = themeDisplay.getPortalURL();
7153    
7154                    if (canonicalURL || !themeDisplay.getServerName().equals(_LOCALHOST)) {
7155                            String virtualHostname = layoutSet.getVirtualHostname();
7156    
7157                            if (Validator.isNull(virtualHostname) &&
7158                                    Validator.isNotNull(
7159                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
7160                                    !layoutSet.isPrivateLayout()) {
7161    
7162                                    try {
7163                                            Group defaultGroup = GroupLocalServiceUtil.getGroup(
7164                                                    themeDisplay.getCompanyId(),
7165                                                    PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
7166    
7167                                            if (layoutSet.getGroupId() == defaultGroup.getGroupId()) {
7168                                                    Company company = themeDisplay.getCompany();
7169    
7170                                                    virtualHostname = company.getVirtualHostname();
7171                                            }
7172                                    }
7173                                    catch (Exception e) {
7174                                            _log.error(e, e);
7175                                    }
7176                            }
7177    
7178                            if (Validator.isNotNull(virtualHostname) &&
7179                                    (canonicalURL ||
7180                                     !virtualHostname.equalsIgnoreCase(_LOCALHOST))) {
7181    
7182                                    virtualHostname = getPortalURL(
7183                                            virtualHostname, themeDisplay.getServerPort(),
7184                                            themeDisplay.isSecure());
7185    
7186                                    String portalDomain = HttpUtil.getDomain(
7187                                            themeDisplay.getPortalURL());
7188    
7189                                    if (canonicalURL || virtualHostname.contains(portalDomain)) {
7190                                            String path = StringPool.BLANK;
7191    
7192                                            if (themeDisplay.isWidget()) {
7193                                                    path = PropsValues.WIDGET_SERVLET_MAPPING;
7194                                            }
7195    
7196                                            if (themeDisplay.isI18n() && !canonicalURL) {
7197                                                    path = themeDisplay.getI18nPath();
7198                                            }
7199    
7200                                            return virtualHostname.concat(_pathContext).concat(path);
7201                                    }
7202                            }
7203                            else {
7204                                    LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7205                                            themeDisplay.getSiteGroupId(), privateLayoutSet);
7206    
7207                                    if (canonicalURL ||
7208                                            ((layoutSet.getLayoutSetId() !=
7209                                                    curLayoutSet.getLayoutSetId()) &&
7210                                             (group.getClassPK() != themeDisplay.getUserId()))) {
7211    
7212                                            if (group.isControlPanel()) {
7213                                                    virtualHostname = themeDisplay.getServerName();
7214    
7215                                                    if (Validator.isNull(virtualHostname) ||
7216                                                            virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
7217    
7218                                                            virtualHostname = curLayoutSet.getVirtualHostname();
7219                                                    }
7220                                            }
7221    
7222                                            if (Validator.isNull(virtualHostname) ||
7223                                                    virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
7224    
7225                                                    Company company = themeDisplay.getCompany();
7226    
7227                                                    virtualHostname = company.getVirtualHostname();
7228                                            }
7229    
7230                                            if (canonicalURL ||
7231                                                    !virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
7232    
7233                                                    portalURL = getPortalURL(
7234                                                            virtualHostname, themeDisplay.getServerPort(),
7235                                                            themeDisplay.isSecure());
7236                                            }
7237                                    }
7238                            }
7239                    }
7240    
7241                    String friendlyURL = null;
7242    
7243                    if (privateLayoutSet) {
7244                            if (group.isUser()) {
7245                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7246                            }
7247                            else {
7248                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7249                            }
7250                    }
7251                    else {
7252                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7253                    }
7254    
7255                    StringBundler sb = new StringBundler(6);
7256    
7257                    sb.append(portalURL);
7258                    sb.append(_pathContext);
7259    
7260                    if (themeDisplay.isI18n() && !canonicalURL) {
7261                            sb.append(themeDisplay.getI18nPath());
7262                    }
7263    
7264                    if (themeDisplay.isWidget()) {
7265                            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7266                    }
7267    
7268                    sb.append(friendlyURL);
7269                    sb.append(group.getFriendlyURL());
7270    
7271                    return sb.toString();
7272            }
7273    
7274            protected String getPortletParam(HttpServletRequest request, String name) {
7275                    String portletId = ParamUtil.getString(request, "p_p_id");
7276    
7277                    if (Validator.isNull(portletId)) {
7278                            return StringPool.BLANK;
7279                    }
7280    
7281                    String value = null;
7282    
7283                    int valueCount = 0;
7284    
7285                    String keyName = StringPool.UNDERLINE.concat(name);
7286    
7287                    Map<String, String[]> parameterMap = request.getParameterMap();
7288    
7289                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7290                            String parameterName = entry.getKey();
7291    
7292                            int pos = parameterName.indexOf(keyName);
7293    
7294                            if (pos == -1) {
7295                                    continue;
7296                            }
7297    
7298                            valueCount++;
7299    
7300                            // There should never be more than one value
7301    
7302                            if (valueCount > 1) {
7303                                    return StringPool.BLANK;
7304                            }
7305    
7306                            String[] parameterValues = entry.getValue();
7307    
7308                            if ((parameterValues == null) || (parameterValues.length == 0) ||
7309                                    Validator.isNull(parameterValues[0])) {
7310    
7311                                    continue;
7312                            }
7313    
7314                            // The Struts action must be for the correct portlet
7315    
7316                            String portletId1 = parameterName.substring(1, pos);
7317    
7318                            if (portletId.equals(portletId1)) {
7319                                    value = parameterValues[0];
7320                            }
7321                    }
7322    
7323                    if (value == null) {
7324                            value = StringPool.BLANK;
7325                    }
7326    
7327                    return value;
7328            }
7329    
7330            protected String getServletURL(
7331                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7332                    throws PortalException, SystemException {
7333    
7334                    Layout layout = themeDisplay.getLayout();
7335    
7336                    StringBundler sb = new StringBundler();
7337    
7338                    sb.append(themeDisplay.getPortalURL());
7339    
7340                    if (Validator.isNotNull(_pathContext)) {
7341                            sb.append(_pathContext);
7342                    }
7343    
7344                    if (themeDisplay.isI18n()) {
7345                            sb.append(themeDisplay.getI18nPath());
7346                    }
7347    
7348                    sb.append(servletPath);
7349    
7350                    Group group = layout.getGroup();
7351    
7352                    if (layout.isPrivateLayout()) {
7353                            if (group.isUser()) {
7354                                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7355                            }
7356                            else {
7357                                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7358                            }
7359                    }
7360                    else {
7361                            sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7362                    }
7363    
7364                    sb.append(group.getFriendlyURL());
7365                    sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7366    
7367                    sb.append(FRIENDLY_URL_SEPARATOR);
7368    
7369                    FriendlyURLMapper friendlyURLMapper =
7370                            portlet.getFriendlyURLMapperInstance();
7371    
7372                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7373                            sb.append(friendlyURLMapper.getMapping());
7374                    }
7375                    else {
7376                            sb.append(portlet.getPortletId());
7377                    }
7378    
7379                    return sb.toString();
7380            }
7381    
7382            protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7383                    throws Exception {
7384    
7385                    String ticketKey = ParamUtil.getString(request, "ticketKey");
7386    
7387                    if (Validator.isNull(ticketKey)) {
7388                            return false;
7389                    }
7390    
7391                    Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7392    
7393                    if ((ticket == null) ||
7394                            (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7395    
7396                            return false;
7397                    }
7398    
7399                    String className = ticket.getClassName();
7400    
7401                    if (!className.equals(User.class.getName())) {
7402                            return false;
7403                    }
7404    
7405                    long doAsUserId = 0;
7406    
7407                    try {
7408                            Company company = getCompany(request);
7409    
7410                            String doAsUserIdString = ParamUtil.getString(
7411                                    request, "doAsUserId");
7412    
7413                            if (Validator.isNotNull(doAsUserIdString)) {
7414                                    doAsUserId = GetterUtil.getLong(
7415                                            Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7416                            }
7417                    }
7418                    catch (Exception e) {
7419                            return false;
7420                    }
7421    
7422                    if (ticket.getClassPK() != doAsUserId) {
7423                            return false;
7424                    }
7425    
7426                    if (ticket.isExpired()) {
7427                            TicketLocalServiceUtil.deleteTicket(ticket);
7428    
7429                            return false;
7430                    }
7431    
7432                    Date expirationDate = new Date(
7433                            System.currentTimeMillis() +
7434                                    PropsValues.SESSION_TIMEOUT * Time.MINUTE);
7435    
7436                    ticket.setExpirationDate(expirationDate);
7437    
7438                    TicketLocalServiceUtil.updateTicket(ticket);
7439    
7440                    return true;
7441            }
7442    
7443            /**
7444             * @deprecated As of 6.2.0 with no direct replacement
7445             */
7446            protected boolean isPanelSelectedPortlet(
7447                    ThemeDisplay themeDisplay, String portletId) {
7448    
7449                    Layout layout = themeDisplay.getLayout();
7450    
7451                    String panelSelectedPortlets = layout.getTypeSettingsProperty(
7452                            "panelSelectedPortlets");
7453    
7454                    if (Validator.isNotNull(panelSelectedPortlets)) {
7455                            String[] panelSelectedPortletsArray = StringUtil.split(
7456                                    panelSelectedPortlets);
7457    
7458                            return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
7459                    }
7460    
7461                    return false;
7462            }
7463    
7464            protected void notifyPortalPortEventListeners(int portalPort) {
7465                    for (PortalPortEventListener portalPortEventListener :
7466                                    _portalPortEventListeners) {
7467    
7468                            portalPortEventListener.portalPortConfigured(portalPort);
7469                    }
7470            }
7471    
7472            protected String removeRedirectParameter(String url) {
7473                    String queryString = HttpUtil.getQueryString(url);
7474    
7475                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
7476                            queryString);
7477    
7478                    for (String parameter : parameterMap.keySet()) {
7479                            if (parameter.endsWith("redirect")) {
7480                                    url = HttpUtil.removeParameter(url, parameter);
7481                            }
7482                    }
7483    
7484                    return url;
7485            }
7486    
7487            protected void resetThemeDisplayI18n(
7488                    ThemeDisplay themeDisplay, String languageId, String path) {
7489    
7490                    themeDisplay.setI18nLanguageId(languageId);
7491                    themeDisplay.setI18nPath(path);
7492            }
7493    
7494            protected void setLocale(
7495                    HttpServletRequest request, HttpServletResponse response,
7496                    Locale locale) {
7497    
7498                    HttpSession session = request.getSession();
7499    
7500                    session.setAttribute(Globals.LOCALE_KEY, locale);
7501    
7502                    LanguageUtil.updateCookie(request, response, locale);
7503            }
7504    
7505            protected void setThemeDisplayI18n(
7506                    ThemeDisplay themeDisplay, Locale locale) {
7507    
7508                    String i18nLanguageId = null;
7509                    String i18nPath = null;
7510    
7511                    if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
7512                             ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
7513                              !locale.equals(LocaleUtil.getDefault()))) ||
7514                            (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
7515    
7516                            i18nLanguageId = locale.toString();
7517                            i18nPath = buildI18NPath(locale);
7518                    }
7519    
7520                    themeDisplay.setI18nLanguageId(i18nLanguageId);
7521                    themeDisplay.setI18nPath(i18nPath);
7522            }
7523    
7524            private static final String _J_SECURITY_CHECK = "j_security_check";
7525    
7526            private static final String _JSESSIONID = ";jsessionid=";
7527    
7528            private static final String _LOCALHOST = "localhost";
7529    
7530            private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
7531                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
7532    
7533            private static final String _PRIVATE_USER_SERVLET_MAPPING =
7534                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
7535    
7536            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
7537                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
7538    
7539            private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
7540    
7541            private static Log _logWebServerServlet = LogFactoryUtil.getLog(
7542                    WebServerServlet.class);
7543    
7544            private static Map<Long, String> _cdnHostHttpMap =
7545                    new ConcurrentHashMap<Long, String>();
7546            private static Map<Long, String> _cdnHostHttpsMap =
7547                    new ConcurrentHashMap<Long, String>();
7548            private static MethodHandler _resetCDNHostsMethodHandler =
7549                    new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
7550            private static Date _upTime = new Date();
7551    
7552            private String[] _allSystemGroups;
7553            private String[] _allSystemOrganizationRoles;
7554            private String[] _allSystemRoles;
7555            private String[] _allSystemSiteRoles;
7556            private Pattern _bannedResourceIdPattern = Pattern.compile(
7557                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
7558                    Pattern.CASE_INSENSITIVE);
7559            private String _computerAddress;
7560            private String _computerName;
7561            private String[] _customSqlKeys;
7562            private String[] _customSqlValues;
7563            private EditDiscussionAction _editDiscussionAction =
7564                    new EditDiscussionAction();
7565            private String _pathContext;
7566            private String _pathFriendlyURLPrivateGroup;
7567            private String _pathFriendlyURLPrivateUser;
7568            private String _pathFriendlyURLPublic;
7569            private String _pathImage;
7570            private String _pathMain;
7571            private String _pathModule;
7572            private String _pathProxy;
7573            private Map<String, Long> _plidToPortletIdMap =
7574                    new ConcurrentHashMap<String, Long>();
7575            private final AtomicInteger _portalPort = new AtomicInteger(-1);
7576            private List<PortalPortEventListener> _portalPortEventListeners =
7577                    new ArrayList<PortalPortEventListener>();
7578            private Set<String> _reservedParams;
7579            private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
7580            private String[] _sortedSystemGroups;
7581            private String[] _sortedSystemOrganizationRoles;
7582            private String[] _sortedSystemRoles;
7583            private String[] _sortedSystemSiteRoles;
7584    
7585    }