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