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