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                    List<PersistentHttpServletRequestWrapper>
5109                            persistentHttpServletRequestWrappers =
5110                                    new ArrayList<PersistentHttpServletRequestWrapper>();
5111    
5112                    HttpServletRequest currentRequest = request;
5113    
5114                    while (currentRequest instanceof HttpServletRequestWrapper) {
5115                            if (currentRequest instanceof UploadServletRequest) {
5116                                    return (UploadServletRequest)currentRequest;
5117                            }
5118    
5119                            if (currentRequest instanceof
5120                                            PersistentHttpServletRequestWrapper) {
5121    
5122                                    PersistentHttpServletRequestWrapper
5123                                            persistentHttpServletRequestWrapper =
5124                                                    (PersistentHttpServletRequestWrapper)currentRequest;
5125    
5126                                    persistentHttpServletRequestWrappers.add(
5127                                            persistentHttpServletRequestWrapper.clone());
5128                            }
5129    
5130                            HttpServletRequestWrapper httpServletRequestWrapper =
5131                                    (HttpServletRequestWrapper)currentRequest;
5132    
5133                            currentRequest =
5134                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
5135                    }
5136    
5137                    if (ServerDetector.isWebLogic()) {
5138                            currentRequest = new NonSerializableObjectRequestWrapper(
5139                                    currentRequest);
5140                    }
5141    
5142                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5143                                    i--) {
5144    
5145                            HttpServletRequestWrapper httpServletRequestWrapper =
5146                                    persistentHttpServletRequestWrappers.get(i);
5147    
5148                            httpServletRequestWrapper.setRequest(currentRequest);
5149    
5150                            currentRequest = httpServletRequestWrapper;
5151                    }
5152    
5153                    return new UploadServletRequestImpl(currentRequest);
5154            }
5155    
5156            @Override
5157            public Date getUptime() {
5158                    return _upTime;
5159            }
5160    
5161            @Override
5162            public String getURLWithSessionId(String url, String sessionId) {
5163                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5164                            return url;
5165                    }
5166    
5167                    if (Validator.isNull(url)) {
5168                            return url;
5169                    }
5170    
5171                    // LEP-4787
5172    
5173                    int x = url.indexOf(CharPool.SEMICOLON);
5174    
5175                    if (x != -1) {
5176                            return url;
5177                    }
5178    
5179                    x = url.indexOf(CharPool.QUESTION);
5180    
5181                    if (x != -1) {
5182                            StringBundler sb = new StringBundler(4);
5183    
5184                            sb.append(url.substring(0, x));
5185                            sb.append(_JSESSIONID);
5186                            sb.append(sessionId);
5187                            sb.append(url.substring(x));
5188    
5189                            return sb.toString();
5190                    }
5191    
5192                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
5193                    // http://www.abc.com/;jsessionid=XYZ does work.
5194    
5195                    x = url.indexOf(StringPool.DOUBLE_SLASH);
5196    
5197                    StringBundler sb = new StringBundler(4);
5198    
5199                    sb.append(url);
5200    
5201                    if (x != -1) {
5202                            int y = url.lastIndexOf(CharPool.SLASH);
5203    
5204                            if ((x + 1) == y) {
5205                                    sb.append(StringPool.SLASH);
5206                            }
5207                    }
5208    
5209                    sb.append(_JSESSIONID);
5210                    sb.append(sessionId);
5211    
5212                    return sb.toString();
5213            }
5214    
5215            @Override
5216            public User getUser(HttpServletRequest request)
5217                    throws PortalException, SystemException {
5218    
5219                    User user = (User)request.getAttribute(WebKeys.USER);
5220    
5221                    if (user != null) {
5222                            return user;
5223                    }
5224    
5225                    long userId = getUserId(request);
5226    
5227                    if (userId <= 0) {
5228    
5229                            // Portlet WARs may have the correct remote user and not have the
5230                            // correct user id because the user id is saved in the session and
5231                            // may not be accessible by the portlet WAR's session. This behavior
5232                            // is inconsistent across different application servers.
5233    
5234                            String remoteUser = request.getRemoteUser();
5235    
5236                            if (remoteUser == null) {
5237                                    return null;
5238                            }
5239    
5240                            userId = GetterUtil.getLong(remoteUser);
5241                    }
5242    
5243                    if (userId > 0) {
5244                            user = UserLocalServiceUtil.getUserById(userId);
5245    
5246                            request.setAttribute(WebKeys.USER, user);
5247                    }
5248    
5249                    Cookie[] cookies = request.getCookies();
5250    
5251                    if (cookies != null) {
5252                            for (Cookie cookie : cookies) {
5253                                    String cookieName = cookie.getName();
5254    
5255                                    if (cookieName.startsWith(
5256                                                    CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5257    
5258                                            user.addRemotePreference(
5259                                                    new CookieRemotePreference(cookie));
5260                                    }
5261                            }
5262                    }
5263    
5264                    return user;
5265            }
5266    
5267            @Override
5268            public User getUser(PortletRequest portletRequest)
5269                    throws PortalException, SystemException {
5270    
5271                    return getUser(getHttpServletRequest(portletRequest));
5272            }
5273    
5274            @Override
5275            public String getUserEmailAddress(long userId) throws SystemException {
5276                    try {
5277                            User user = UserLocalServiceUtil.getUserById(userId);
5278    
5279                            return user.getEmailAddress();
5280                    }
5281                    catch (PortalException pe) {
5282                            return StringPool.BLANK;
5283                    }
5284            }
5285    
5286            @Override
5287            public long getUserId(HttpServletRequest request) {
5288                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5289    
5290                    if (userIdObj != null) {
5291                            return userIdObj.longValue();
5292                    }
5293    
5294                    String path = GetterUtil.getString(request.getPathInfo());
5295                    String strutsAction = getStrutsAction(request);
5296                    String actionName = getPortletParam(request, "actionName");
5297    
5298                    boolean alwaysAllowDoAsUser = false;
5299    
5300                    if (path.equals("/portal/session_click") ||
5301                            strutsAction.equals("/document_library/edit_file_entry") ||
5302                            strutsAction.equals("/document_library_display/edit_file_entry") ||
5303                            strutsAction.equals("/image_gallery_display/edit_file_entry") ||
5304                            strutsAction.equals("/image_gallery_display/edit_image") ||
5305                            strutsAction.equals("/wiki/edit_page_attachment") ||
5306                            strutsAction.equals("/wiki_admin/edit_page_attachment") ||
5307                            strutsAction.equals("/wiki_display/edit_page_attachment") ||
5308                            actionName.equals("addFile")) {
5309    
5310                            try {
5311                                    alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5312                            }
5313                            catch (Exception e) {
5314                                    _log.error(e, e);
5315                            }
5316                    }
5317    
5318                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5319                             PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5320                            alwaysAllowDoAsUser) {
5321    
5322                            String doAsUserIdString = ParamUtil.getString(
5323                                    request, "doAsUserId");
5324    
5325                            try {
5326                                    long doAsUserId = getDoAsUserId(
5327                                            request, doAsUserIdString, alwaysAllowDoAsUser);
5328    
5329                                    if (doAsUserId > 0) {
5330                                            if (_log.isDebugEnabled()) {
5331                                                    _log.debug("Impersonating user " + doAsUserId);
5332                                            }
5333    
5334                                            return doAsUserId;
5335                                    }
5336                            }
5337                            catch (Exception e) {
5338                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
5339                            }
5340                    }
5341    
5342                    HttpSession session = request.getSession();
5343    
5344                    userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5345    
5346                    if (userIdObj != null) {
5347                            request.setAttribute(WebKeys.USER_ID, userIdObj);
5348    
5349                            return userIdObj.longValue();
5350                    }
5351                    else {
5352                            return 0;
5353                    }
5354            }
5355    
5356            @Override
5357            public long getUserId(PortletRequest portletRequest) {
5358                    return getUserId(getHttpServletRequest(portletRequest));
5359            }
5360    
5361            @Override
5362            public String getUserName(BaseModel<?> baseModel) {
5363                    long userId = 0;
5364                    String userName = StringPool.BLANK;
5365    
5366                    if (baseModel instanceof AuditedModel) {
5367                            AuditedModel auditedModel = (AuditedModel)baseModel;
5368    
5369                            userId = auditedModel.getUserId();
5370                            userName = auditedModel.getUserName();
5371                    }
5372                    else {
5373                            userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5374                            userName = BeanPropertiesUtil.getStringSilent(
5375                                    baseModel, "userName");
5376                    }
5377    
5378                    if (userId == 0) {
5379                            return StringPool.BLANK;
5380                    }
5381    
5382                    if (baseModel.isEscapedModel()) {
5383                            userName = HtmlUtil.unescape(userName);
5384                    }
5385    
5386                    userName = getUserName(userId, userName);
5387    
5388                    if (baseModel.isEscapedModel()) {
5389                            userName = HtmlUtil.escape(userName);
5390                    }
5391    
5392                    return userName;
5393            }
5394    
5395            @Override
5396            public String getUserName(long userId, String defaultUserName) {
5397                    return getUserName(
5398                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5399            }
5400    
5401            @Override
5402            public String getUserName(
5403                    long userId, String defaultUserName, HttpServletRequest request) {
5404    
5405                    return getUserName(
5406                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5407            }
5408    
5409            @Override
5410            public String getUserName(
5411                    long userId, String defaultUserName, String userAttribute) {
5412    
5413                    return getUserName(userId, defaultUserName, userAttribute, null);
5414            }
5415    
5416            @Override
5417            public String getUserName(
5418                    long userId, String defaultUserName, String userAttribute,
5419                    HttpServletRequest request) {
5420    
5421                    String userName = defaultUserName;
5422    
5423                    try {
5424                            User user = UserLocalServiceUtil.getUserById(userId);
5425    
5426                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5427                                    userName = user.getFullName();
5428                            }
5429                            else {
5430                                    userName = user.getScreenName();
5431                            }
5432    
5433                            if (request != null) {
5434                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5435    
5436                                    PortletURL portletURL = new PortletURLImpl(
5437                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
5438                                            PortletRequest.RENDER_PHASE);
5439    
5440                                    portletURL.setParameter(
5441                                            "struts_action", "/directory/view_user");
5442                                    portletURL.setParameter(
5443                                            "p_u_i_d", String.valueOf(user.getUserId()));
5444                                    portletURL.setPortletMode(PortletMode.VIEW);
5445                                    portletURL.setWindowState(WindowState.MAXIMIZED);
5446    
5447                                    userName =
5448                                            "<a href=\"" + portletURL.toString() + "\">" +
5449                                                    HtmlUtil.escape(userName) + "</a>";
5450                            }
5451                    }
5452                    catch (Exception e) {
5453                    }
5454    
5455                    return userName;
5456            }
5457    
5458            @Override
5459            public String getUserPassword(HttpServletRequest request) {
5460                    HttpSession session = request.getSession();
5461    
5462                    return getUserPassword(session);
5463            }
5464    
5465            @Override
5466            public String getUserPassword(HttpSession session) {
5467                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5468            }
5469    
5470            @Override
5471            public String getUserPassword(PortletRequest portletRequest) {
5472                    return getUserPassword(getHttpServletRequest(portletRequest));
5473            }
5474    
5475            @Override
5476            public String getUserValue(long userId, String param, String defaultValue)
5477                    throws SystemException {
5478    
5479                    if (Validator.isNotNull(defaultValue)) {
5480                            return defaultValue;
5481                    }
5482    
5483                    try {
5484                            User user = UserLocalServiceUtil.getUserById(userId);
5485    
5486                            return BeanPropertiesUtil.getString(user, param, defaultValue);
5487                    }
5488                    catch (PortalException pe) {
5489                            return StringPool.BLANK;
5490                    }
5491            }
5492    
5493            @Override
5494            public long getValidUserId(long companyId, long userId)
5495                    throws PortalException, SystemException {
5496    
5497                    User user = UserLocalServiceUtil.fetchUser(userId);
5498    
5499                    if (user == null) {
5500                            return UserLocalServiceUtil.getDefaultUserId(companyId);
5501                    }
5502    
5503                    if (user.getCompanyId() == companyId) {
5504                            return user.getUserId();
5505                    }
5506    
5507                    return userId;
5508            }
5509    
5510            @Override
5511            public String getVirtualLayoutActualURL(
5512                            long groupId, boolean privateLayout, String mainPath,
5513                            String friendlyURL, Map<String, String[]> params,
5514                            Map<String, Object> requestContext)
5515                    throws PortalException, SystemException {
5516    
5517                    // Group friendly URL
5518    
5519                    String groupFriendlyURL = null;
5520    
5521                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5522    
5523                    if (pos != -1) {
5524                            groupFriendlyURL = friendlyURL.substring(2, pos);
5525                    }
5526    
5527                    if (Validator.isNull(groupFriendlyURL)) {
5528                            return mainPath;
5529                    }
5530    
5531                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5532                            "request");
5533    
5534                    long companyId = PortalInstances.getCompanyId(request);
5535    
5536                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5537                            companyId, groupFriendlyURL);
5538    
5539                    if (group == null) {
5540                            return mainPath;
5541                    }
5542    
5543                    // Layout friendly URL
5544    
5545                    String layoutFriendlyURL = null;
5546    
5547                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5548                            layoutFriendlyURL = friendlyURL.substring(pos);
5549                    }
5550    
5551                    if (Validator.isNull(layoutFriendlyURL)) {
5552                            return mainPath;
5553                    }
5554    
5555                    String actualURL = getActualURL(
5556                            group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
5557                            params, requestContext);
5558    
5559                    return HttpUtil.addParameter(
5560                            HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
5561                            groupId);
5562            }
5563    
5564            @Override
5565            public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5566                            boolean privateLayout, String friendlyURL,
5567                            Map<String, String[]> params, Map<String, Object> requestContext)
5568                    throws PortalException, SystemException {
5569    
5570                    // Group friendly URL
5571    
5572                    String groupFriendlyURL = null;
5573    
5574                    int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5575    
5576                    if (pos != -1) {
5577                            groupFriendlyURL = friendlyURL.substring(2, pos);
5578                    }
5579    
5580                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5581                            "request");
5582    
5583                    long companyId = PortalInstances.getCompanyId(request);
5584    
5585                    Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5586                            companyId, groupFriendlyURL);
5587    
5588                    // Layout friendly URL
5589    
5590                    String layoutFriendlyURL = null;
5591    
5592                    if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5593                            layoutFriendlyURL = friendlyURL.substring(pos);
5594                    }
5595    
5596                    LayoutQueryStringComposite layoutQueryStringComposite =
5597                            getActualLayoutQueryStringComposite(
5598                                    group.getGroupId(), privateLayout, layoutFriendlyURL, params,
5599                                    requestContext);
5600    
5601                    return new LayoutFriendlyURLComposite(
5602                            layoutQueryStringComposite.getLayout(), layoutFriendlyURL);
5603            }
5604    
5605            @Override
5606            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5607                    throws PortalException, SystemException {
5608    
5609                    return getServletURL(
5610                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5611            }
5612    
5613            @Override
5614            public void initCustomSQL() {
5615                    _customSqlKeys = new String[] {
5616                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5617                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5618                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5619                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5620                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5621                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5622                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5623                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5624                                    "BOOKMARKSENTRY$]",
5625                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5626                                    "BOOKMARKSFOLDER$]",
5627                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5628                                    "DLFILEENTRY$]",
5629                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5630                                    "DLFOLDER$]",
5631                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.JOURNAL.MODEL." +
5632                                    "JOURNALFOLDER$]",
5633                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5634                                    "MBMESSAGE$]",
5635                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5636                                    "MBTHREAD$]",
5637                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
5638                            "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5639                            "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5640                            "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5641                            "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5642                            "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5643                            "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5644                            "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5645                            "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5646                            "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5647                            "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5648                            "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5649                            "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5650                            "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5651                            "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5652                    };
5653    
5654                    DB db = DBFactoryUtil.getDB();
5655    
5656                    Object[] customSqlValues = new Object[] {
5657                            getClassNameId(Group.class), getClassNameId(Layout.class),
5658                            getClassNameId(Organization.class), getClassNameId(Role.class),
5659                            getClassNameId(User.class), getClassNameId(UserGroup.class),
5660                            getClassNameId(BlogsEntry.class),
5661                            getClassNameId(BookmarksEntry.class),
5662                            getClassNameId(BookmarksFolder.class),
5663                            getClassNameId(DLFileEntry.class), getClassNameId(DLFolder.class),
5664                            getClassNameId(JournalFolder.class),
5665                            getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
5666                            getClassNameId(WikiPage.class), ResourceConstants.SCOPE_COMPANY,
5667                            ResourceConstants.SCOPE_GROUP,
5668                            ResourceConstants.SCOPE_GROUP_TEMPLATE,
5669                            ResourceConstants.SCOPE_INDIVIDUAL,
5670                            SocialRelationConstants.TYPE_BI_COWORKER,
5671                            SocialRelationConstants.TYPE_BI_FRIEND,
5672                            SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5673                            SocialRelationConstants.TYPE_BI_SIBLING,
5674                            SocialRelationConstants.TYPE_BI_SPOUSE,
5675                            SocialRelationConstants.TYPE_UNI_CHILD,
5676                            SocialRelationConstants.TYPE_UNI_ENEMY,
5677                            SocialRelationConstants.TYPE_UNI_FOLLOWER,
5678                            SocialRelationConstants.TYPE_UNI_PARENT,
5679                            SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5680                            SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5681                            db.getTemplateTrue()
5682                    };
5683    
5684                    _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5685            }
5686    
5687            @Override
5688            public User initUser(HttpServletRequest request) throws Exception {
5689                    User user = null;
5690    
5691                    try {
5692                            user = getUser(request);
5693                    }
5694                    catch (NoSuchUserException nsue) {
5695                            if (_log.isWarnEnabled()) {
5696                                    _log.warn(nsue.getMessage());
5697                            }
5698    
5699                            long userId = getUserId(request);
5700    
5701                            if (userId > 0) {
5702                                    HttpSession session = request.getSession();
5703    
5704                                    session.invalidate();
5705                            }
5706    
5707                            throw nsue;
5708                    }
5709    
5710                    if (user != null) {
5711                            return user;
5712                    }
5713    
5714                    Company company = getCompany(request);
5715    
5716                    return company.getDefaultUser();
5717            }
5718    
5719            @Override
5720            public void invokeTaglibDiscussion(
5721                            PortletConfig portletConfig, ActionRequest actionRequest,
5722                            ActionResponse actionResponse)
5723                    throws Exception {
5724    
5725                    _editDiscussionAction.processAction(
5726                            null, null, portletConfig, actionRequest, actionResponse);
5727            }
5728    
5729            /**
5730             * @deprecated As of 6.2.0 with no direct replacement
5731             */
5732            @Override
5733            public boolean isAllowAddPortletDefaultResource(
5734                            HttpServletRequest request, Portlet portlet)
5735                    throws PortalException, SystemException {
5736    
5737                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5738                            WebKeys.THEME_DISPLAY);
5739    
5740                    Layout layout = themeDisplay.getLayout();
5741                    LayoutTypePortlet layoutTypePortlet =
5742                            themeDisplay.getLayoutTypePortlet();
5743    
5744                    String portletId = portlet.getPortletId();
5745    
5746                    Boolean renderPortletResource = (Boolean)request.getAttribute(
5747                            WebKeys.RENDER_PORTLET_RESOURCE);
5748    
5749                    if (renderPortletResource != null) {
5750                            boolean runtimePortlet = renderPortletResource.booleanValue();
5751    
5752                            if (runtimePortlet) {
5753                                    return true;
5754                            }
5755                    }
5756    
5757                    if (layout.isTypePanel() &&
5758                            isPanelSelectedPortlet(themeDisplay, portletId)) {
5759    
5760                            return true;
5761                    }
5762    
5763                    if (layout.isTypeControlPanel() &&
5764                            isControlPanelPortlet(portletId, themeDisplay)) {
5765    
5766                            return true;
5767                    }
5768    
5769                    if ((layoutTypePortlet != null) &&
5770                            layoutTypePortlet.hasPortletId(portletId)) {
5771    
5772                            return true;
5773                    }
5774    
5775                    if (themeDisplay.isSignedIn() &&
5776                            portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
5777    
5778                            PermissionChecker permissionChecker =
5779                                    themeDisplay.getPermissionChecker();
5780    
5781                            Group group = layout.getGroup();
5782    
5783                            if (group.isSite()) {
5784                                    if (LayoutPermissionUtil.contains(
5785                                                    permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
5786                                            LayoutPermissionUtil.contains(
5787                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
5788    
5789                                            return true;
5790                                    }
5791                            }
5792    
5793                            if (group.isCompany()) {
5794                                    if (permissionChecker.isCompanyAdmin()) {
5795                                            return true;
5796                                    }
5797                            }
5798                            else if (group.isLayoutPrototype()) {
5799                                    long layoutPrototypeId = group.getClassPK();
5800    
5801                                    if (LayoutPrototypePermissionUtil.contains(
5802                                                    permissionChecker, layoutPrototypeId,
5803                                                    ActionKeys.UPDATE)) {
5804    
5805                                            return true;
5806                                    }
5807                            }
5808                            else if (group.isLayoutSetPrototype()) {
5809                                    long layoutSetPrototypeId = group.getClassPK();
5810    
5811                                    if (LayoutSetPrototypePermissionUtil.contains(
5812                                                    permissionChecker, layoutSetPrototypeId,
5813                                                    ActionKeys.UPDATE)) {
5814    
5815                                            return true;
5816                                    }
5817                            }
5818                            else if (group.isOrganization()) {
5819                                    long organizationId = group.getOrganizationId();
5820    
5821                                    if (OrganizationPermissionUtil.contains(
5822                                                    permissionChecker, organizationId, ActionKeys.UPDATE)) {
5823    
5824                                            return true;
5825                                    }
5826                            }
5827                            else if (group.isUserGroup()) {
5828                                    long scopeGroupId = themeDisplay.getScopeGroupId();
5829    
5830                                    if (GroupPermissionUtil.contains(
5831                                                    permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
5832    
5833                                            return true;
5834                                    }
5835                            }
5836                            else if (group.isUser()) {
5837                                    return true;
5838                            }
5839                    }
5840    
5841                    if (!portlet.isAddDefaultResource()) {
5842                            return false;
5843                    }
5844    
5845                    if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
5846                            return true;
5847                    }
5848    
5849                    Set<String> whiteList =
5850                            AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
5851    
5852                    if (whiteList.contains(portletId)) {
5853                            return true;
5854                    }
5855    
5856                    String namespace = getPortletNamespace(portletId);
5857    
5858                    String strutsAction = ParamUtil.getString(
5859                            request, namespace + "struts_action");
5860    
5861                    if (Validator.isNull(strutsAction)) {
5862                            strutsAction = ParamUtil.getString(request, "struts_action");
5863                    }
5864    
5865                    Set<String> whitelistActions =
5866                            AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
5867    
5868                    if (whitelistActions.contains(strutsAction)) {
5869                            return true;
5870                    }
5871    
5872                    String requestPortletAuthenticationToken = ParamUtil.getString(
5873                            request, "p_p_auth");
5874    
5875                    if (Validator.isNull(requestPortletAuthenticationToken)) {
5876                            HttpServletRequest originalRequest = getOriginalServletRequest(
5877                                    request);
5878    
5879                            requestPortletAuthenticationToken = ParamUtil.getString(
5880                                    originalRequest, "p_p_auth");
5881                    }
5882    
5883                    if (Validator.isNotNull(requestPortletAuthenticationToken)) {
5884                            String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
5885                                    request, layout.getPlid(), portletId);
5886    
5887                            if (requestPortletAuthenticationToken.equals(
5888                                            actualPortletAuthenticationToken)) {
5889    
5890                                    return true;
5891                            }
5892                    }
5893    
5894                    return false;
5895            }
5896    
5897            @Override
5898            public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
5899                    throws PortalException, SystemException {
5900    
5901                    Company company = getCompany(request);
5902    
5903                    return isCDNDynamicResourcesEnabled(company.getCompanyId());
5904            }
5905    
5906            @Override
5907            public boolean isCDNDynamicResourcesEnabled(long companyId) {
5908                    try {
5909                            return PrefsPropsUtil.getBoolean(
5910                                    companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
5911                                    PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
5912                    }
5913                    catch (SystemException se) {
5914                    }
5915    
5916                    return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
5917            }
5918    
5919            /**
5920             * @deprecated As of 6.1.0, renamed to {@link #isGroupAdmin(User, long)}
5921             */
5922            @Override
5923            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
5924                    return isGroupAdmin(user, groupId);
5925            }
5926    
5927            /**
5928             * @deprecated As of 6.1.0, renamed to {@link #isGroupOwner(User, long)}
5929             */
5930            @Override
5931            public boolean isCommunityOwner(User user, long groupId) throws Exception {
5932                    return isGroupOwner(user, groupId);
5933            }
5934    
5935            @Override
5936            public boolean isCompanyAdmin(User user) throws Exception {
5937                    PermissionChecker permissionChecker =
5938                            PermissionCheckerFactoryUtil.create(user);
5939    
5940                    return permissionChecker.isCompanyAdmin();
5941            }
5942    
5943            @Override
5944            public boolean isCompanyControlPanelPortlet(
5945                            String portletId, String category, ThemeDisplay themeDisplay)
5946                    throws PortalException, SystemException {
5947    
5948                    PermissionChecker permissionChecker =
5949                            themeDisplay.getPermissionChecker();
5950    
5951                    if (permissionChecker.isCompanyAdmin()) {
5952                            return true;
5953                    }
5954    
5955                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5956                            themeDisplay.getCompanyId());
5957    
5958                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5959    
5960                    return isControlPanelPortlet(portletId, category, themeDisplay);
5961            }
5962    
5963            @Override
5964            public boolean isCompanyControlPanelPortlet(
5965                            String portletId, ThemeDisplay themeDisplay)
5966                    throws PortalException, SystemException {
5967    
5968                    PermissionChecker permissionChecker =
5969                            themeDisplay.getPermissionChecker();
5970    
5971                    if (permissionChecker.isCompanyAdmin()) {
5972                            return true;
5973                    }
5974    
5975                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5976                            themeDisplay.getCompanyId());
5977    
5978                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5979    
5980                    return isControlPanelPortlet(portletId, themeDisplay);
5981            }
5982    
5983            @Override
5984            public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
5985                    throws PortalException, SystemException {
5986    
5987                    PermissionChecker permissionChecker =
5988                            themeDisplay.getPermissionChecker();
5989    
5990                    if (permissionChecker.isCompanyAdmin()) {
5991                            return true;
5992                    }
5993    
5994                    long scopeGroupId = themeDisplay.getScopeGroupId();
5995    
5996                    try {
5997                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5998                                    themeDisplay.getCompanyId());
5999    
6000                            themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6001    
6002                            List<Portlet> controlPanelPortlets = getControlPanelPortlets(
6003                                    PortletCategoryKeys.SITE_ADMINISTRATION, themeDisplay);
6004    
6005                            if (!controlPanelPortlets.isEmpty()) {
6006                                    return true;
6007                            }
6008                            else {
6009                                    return false;
6010                            }
6011                    }
6012                    finally {
6013                            themeDisplay.setScopeGroupId(scopeGroupId);
6014                    }
6015            }
6016    
6017            @Override
6018            public boolean isControlPanelPortlet(
6019                            String portletId, String category, ThemeDisplay themeDisplay)
6020                    throws SystemException {
6021    
6022                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
6023                            themeDisplay.getCompanyId(), portletId);
6024    
6025                    String controlPanelEntryCategory =
6026                            portlet.getControlPanelEntryCategory();
6027    
6028                    if (controlPanelEntryCategory.equals(category) ||
6029                            (category.endsWith(StringPool.PERIOD) &&
6030                             StringUtil.startsWith(controlPanelEntryCategory, category))) {
6031    
6032                            return isControlPanelPortlet(portletId, themeDisplay);
6033                    }
6034    
6035                    return false;
6036            }
6037    
6038            @Override
6039            public boolean isControlPanelPortlet(
6040                            String portletId, ThemeDisplay themeDisplay)
6041                    throws SystemException {
6042    
6043                    try {
6044                            return PortletPermissionUtil.hasControlPanelAccessPermission(
6045                                    themeDisplay.getPermissionChecker(),
6046                                    themeDisplay.getScopeGroupId(), portletId);
6047                    }
6048                    catch (PortalException pe) {
6049                            _log.warn("Unable to check control panel access permission", pe);
6050                    }
6051    
6052                    return false;
6053            }
6054    
6055            @Override
6056            public boolean isGroupAdmin(User user, long groupId) throws Exception {
6057                    PermissionChecker permissionChecker =
6058                            PermissionCheckerFactoryUtil.create(user);
6059    
6060                    return permissionChecker.isGroupAdmin(groupId);
6061            }
6062    
6063            @Override
6064            public boolean isGroupFriendlyURL(
6065                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6066    
6067                    if (fullURL.endsWith(groupFriendlyURL) &&
6068                            !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6069    
6070                            return true;
6071                    }
6072    
6073                    return false;
6074            }
6075    
6076            @Override
6077            public boolean isGroupOwner(User user, long groupId) throws Exception {
6078                    PermissionChecker permissionChecker =
6079                            PermissionCheckerFactoryUtil.create(user);
6080    
6081                    return permissionChecker.isGroupOwner(groupId);
6082            }
6083    
6084            @Override
6085            public boolean isLayoutDescendant(Layout layout, long layoutId)
6086                    throws PortalException, SystemException {
6087    
6088                    if (layout.getLayoutId() == layoutId) {
6089                            return true;
6090                    }
6091    
6092                    for (Layout childLayout : layout.getChildren()) {
6093                            if (isLayoutDescendant(childLayout, layoutId)) {
6094                                    return true;
6095                            }
6096                    }
6097    
6098                    return false;
6099            }
6100    
6101            @Override
6102            public boolean isLayoutFirstPageable(Layout layout) {
6103                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6104    
6105                    return layoutSettings.isFirstPageable();
6106            }
6107    
6108            @Override
6109            public boolean isLayoutFirstPageable(String type) {
6110                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6111    
6112                    return layoutSettings.isFirstPageable();
6113            }
6114    
6115            @Override
6116            public boolean isLayoutFriendliable(Layout layout) {
6117                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6118    
6119                    return layoutSettings.isURLFriendliable();
6120            }
6121    
6122            @Override
6123            public boolean isLayoutFriendliable(String type) {
6124                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6125    
6126                    return layoutSettings.isURLFriendliable();
6127            }
6128    
6129            @Override
6130            public boolean isLayoutParentable(Layout layout) {
6131                    return isLayoutParentable(layout.getType());
6132            }
6133    
6134            @Override
6135            public boolean isLayoutParentable(String type) {
6136                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6137    
6138                    return layoutSettings.isParentable();
6139            }
6140    
6141            @Override
6142            public boolean isLayoutSitemapable(Layout layout) {
6143                    if (layout.isPrivateLayout()) {
6144                            return false;
6145                    }
6146    
6147                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6148    
6149                    return layoutSettings.isSitemapable();
6150            }
6151    
6152            @Override
6153            public boolean isLoginRedirectRequired(HttpServletRequest request)
6154                    throws SystemException {
6155    
6156                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6157                            !request.isSecure()) {
6158    
6159                            return true;
6160                    }
6161    
6162                    long companyId = PortalUtil.getCompanyId(request);
6163    
6164                    if (PrefsPropsUtil.getBoolean(
6165                                    companyId, PropsKeys.CAS_AUTH_ENABLED,
6166                                    PropsValues.CAS_AUTH_ENABLED) ||
6167                            PrefsPropsUtil.getBoolean(
6168                                    companyId, PropsKeys.LOGIN_DIALOG_DISABLED,
6169                                    PropsValues.LOGIN_DIALOG_DISABLED) ||
6170                            PrefsPropsUtil.getBoolean(
6171                                    companyId, PropsKeys.NTLM_AUTH_ENABLED,
6172                                    PropsValues.NTLM_AUTH_ENABLED) ||
6173                            PrefsPropsUtil.getBoolean(
6174                                    companyId, PropsKeys.OPEN_SSO_AUTH_ENABLED,
6175                                    PropsValues.OPEN_SSO_AUTH_ENABLED)) {
6176    
6177                            return true;
6178                    }
6179    
6180                    return false;
6181            }
6182    
6183            @Override
6184            public boolean isMethodGet(PortletRequest portletRequest) {
6185                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6186    
6187                    String method = GetterUtil.getString(request.getMethod());
6188    
6189                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6190                            return true;
6191                    }
6192                    else {
6193                            return false;
6194                    }
6195            }
6196    
6197            @Override
6198            public boolean isMethodPost(PortletRequest portletRequest) {
6199                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6200    
6201                    String method = GetterUtil.getString(request.getMethod());
6202    
6203                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6204                            return true;
6205                    }
6206                    else {
6207                            return false;
6208                    }
6209            }
6210    
6211            @Override
6212            public boolean isMultipartRequest(HttpServletRequest request) {
6213                    String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6214    
6215                    if ((contentType != null) &&
6216                            contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6217    
6218                            return true;
6219                    }
6220                    else {
6221                            return false;
6222                    }
6223            }
6224    
6225            @Override
6226            public boolean isOmniadmin(long userId) {
6227                    return OmniadminUtil.isOmniadmin(userId);
6228            }
6229    
6230            @Override
6231            public boolean isReservedParameter(String name) {
6232                    return _reservedParams.contains(name);
6233            }
6234    
6235            @Override
6236            public boolean isRSSFeedsEnabled() {
6237                    return PropsValues.RSS_FEEDS_ENABLED;
6238            }
6239    
6240            @Override
6241            public boolean isSecure(HttpServletRequest request) {
6242                    HttpSession session = request.getSession();
6243    
6244                    if (session == null) {
6245                            return request.isSecure();
6246                    }
6247    
6248                    Boolean httpsInitial = (Boolean)session.getAttribute(
6249                            WebKeys.HTTPS_INITIAL);
6250    
6251                    boolean secure = false;
6252    
6253                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6254                            !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6255                            (httpsInitial != null) && !httpsInitial.booleanValue()) {
6256    
6257                            secure = false;
6258                    }
6259                    else {
6260                            secure = request.isSecure();
6261                    }
6262    
6263                    return secure;
6264            }
6265    
6266            @Override
6267            public boolean isSystemGroup(String groupName) {
6268                    if (groupName == null) {
6269                            return false;
6270                    }
6271    
6272                    groupName = groupName.trim();
6273    
6274                    int pos = Arrays.binarySearch(
6275                            _sortedSystemGroups, groupName, new StringComparator());
6276    
6277                    if (pos >= 0) {
6278                            return true;
6279                    }
6280                    else {
6281                            return false;
6282                    }
6283            }
6284    
6285            @Override
6286            public boolean isSystemRole(String roleName) {
6287                    if (roleName == null) {
6288                            return false;
6289                    }
6290    
6291                    roleName = roleName.trim();
6292    
6293                    int pos = Arrays.binarySearch(
6294                            _sortedSystemRoles, roleName, new StringComparator());
6295    
6296                    if (pos >= 0) {
6297                            return true;
6298                    }
6299    
6300                    pos = Arrays.binarySearch(
6301                            _sortedSystemSiteRoles, roleName, new StringComparator());
6302    
6303                    if (pos >= 0) {
6304                            return true;
6305                    }
6306    
6307                    pos = Arrays.binarySearch(
6308                            _sortedSystemOrganizationRoles, roleName, new StringComparator());
6309    
6310                    if (pos >= 0) {
6311                            return true;
6312                    }
6313    
6314                    return false;
6315            }
6316    
6317            @Override
6318            public boolean isUpdateAvailable() throws SystemException {
6319                    return PluginPackageUtil.isUpdateAvailable();
6320            }
6321    
6322            @Override
6323            public boolean isValidResourceId(String resourceId) {
6324                    if (Validator.isNull(resourceId)) {
6325                            return true;
6326                    }
6327    
6328                    Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6329    
6330                    if (matcher.matches()) {
6331                            return false;
6332                    }
6333    
6334                    return true;
6335            }
6336    
6337            @Override
6338            public void removePortalPortEventListener(
6339                    PortalPortEventListener portalPortEventListener) {
6340    
6341                    _portalPortEventListeners.remove(portalPortEventListener);
6342            }
6343    
6344            @Override
6345            public void resetCDNHosts() {
6346                    _cdnHostHttpMap.clear();
6347                    _cdnHostHttpsMap.clear();
6348    
6349                    if (!ClusterInvokeThreadLocal.isEnabled()) {
6350                            return;
6351                    }
6352    
6353                    ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6354                            _resetCDNHostsMethodHandler, true);
6355    
6356                    try {
6357                            ClusterExecutorUtil.execute(clusterRequest);
6358                    }
6359                    catch (Exception e) {
6360                            _log.error("Unable to clear cluster wide CDN hosts", e);
6361                    }
6362            }
6363    
6364            /**
6365             * @deprecated As of 6.2.0, replaced by {@link
6366             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelist}
6367             */
6368            @Override
6369            public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6370                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6371            }
6372    
6373            /**
6374             * @deprecated As of 6.2.0, replaced by {@link
6375             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelistActions}
6376             */
6377            @Override
6378            public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6379                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6380            }
6381    
6382            @Override
6383            public void sendError(
6384                            Exception e, ActionRequest actionRequest,
6385                            ActionResponse actionResponse)
6386                    throws IOException {
6387    
6388                    sendError(0, e, actionRequest, actionResponse);
6389            }
6390    
6391            @Override
6392            public void sendError(
6393                            Exception e, HttpServletRequest request,
6394                            HttpServletResponse response)
6395                    throws IOException, ServletException {
6396    
6397                    sendError(0, e, request, response);
6398            }
6399    
6400            @Override
6401            public void sendError(
6402                            int status, Exception e, ActionRequest actionRequest,
6403                            ActionResponse actionResponse)
6404                    throws IOException {
6405    
6406                    StringBundler sb = new StringBundler(7);
6407    
6408                    sb.append(_pathMain);
6409                    sb.append("/portal/status?status=");
6410                    sb.append(status);
6411                    sb.append("&exception=");
6412                    sb.append(e.getClass().getName());
6413                    sb.append("&previousURL=");
6414                    sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6415    
6416                    actionResponse.sendRedirect(sb.toString());
6417            }
6418    
6419            @Override
6420            public void sendError(
6421                            int status, Exception e, HttpServletRequest request,
6422                            HttpServletResponse response)
6423                    throws IOException, ServletException {
6424    
6425                    if (_log.isDebugEnabled()) {
6426                            String currentURL = (String)request.getAttribute(
6427                                    WebKeys.CURRENT_URL);
6428    
6429                            _log.debug(
6430                                    "Current URL " + currentURL + " generates exception: " +
6431                                            e.getMessage());
6432                    }
6433    
6434                    if (e instanceof NoSuchImageException) {
6435                            if (_logWebServerServlet.isWarnEnabled()) {
6436                                    _logWebServerServlet.warn(e, e);
6437                            }
6438                    }
6439                    else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6440                            if ((e instanceof NoSuchLayoutException) ||
6441                                    (e instanceof PrincipalException)) {
6442    
6443                                    String msg = e.getMessage();
6444    
6445                                    if (Validator.isNotNull(msg)) {
6446                                            _log.debug(msg);
6447                                    }
6448                            }
6449                            else {
6450                                    _log.debug(e, e);
6451                            }
6452                    }
6453                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6454                            _log.warn(e, e);
6455                    }
6456    
6457                    if (response.isCommitted()) {
6458                            return;
6459                    }
6460    
6461                    if (status == 0) {
6462                            if (e instanceof PrincipalException) {
6463                                    status = HttpServletResponse.SC_FORBIDDEN;
6464                            }
6465                            else {
6466                                    String name = e.getClass().getName();
6467    
6468                                    name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6469    
6470                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6471                                            status = HttpServletResponse.SC_NOT_FOUND;
6472                                    }
6473                            }
6474    
6475                            if (status == 0) {
6476    
6477                                    // LPS-5352
6478    
6479                                    if (PropsValues.TCK_URL) {
6480                                            status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
6481                                    }
6482                                    else {
6483                                            status = HttpServletResponse.SC_BAD_REQUEST;
6484                                    }
6485                            }
6486                    }
6487    
6488                    HttpSession session = PortalSessionThreadLocal.getHttpSession();
6489    
6490                    if (session == null) {
6491                            session = request.getSession();
6492                    }
6493    
6494                    ServletContext servletContext = session.getServletContext();
6495    
6496                    String redirect = PATH_MAIN + "/portal/status";
6497    
6498                    if ((e instanceof NoSuchLayoutException) &&
6499                            Validator.isNotNull(
6500                                    PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6501    
6502                            response.setStatus(status);
6503    
6504                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6505    
6506                            RequestDispatcher requestDispatcher =
6507                                    servletContext.getRequestDispatcher(redirect);
6508    
6509                            if (requestDispatcher != null) {
6510                                    requestDispatcher.forward(request, response);
6511                            }
6512                    }
6513                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6514                            response.setStatus(status);
6515    
6516                            SessionErrors.add(session, e.getClass(), e);
6517    
6518                            RequestDispatcher requestDispatcher =
6519                                    servletContext.getRequestDispatcher(redirect);
6520    
6521                            if (requestDispatcher != null) {
6522                                    requestDispatcher.forward(request, response);
6523                            }
6524                    }
6525                    else if (e != null) {
6526                            response.sendError(status, e.getMessage());
6527                    }
6528                    else {
6529                            String currentURL = (String)request.getAttribute(
6530                                    WebKeys.CURRENT_URL);
6531    
6532                            response.sendError(status, "Current URL " + currentURL);
6533                    }
6534            }
6535    
6536            @Override
6537            public void sendRSSFeedsDisabledError(
6538                            HttpServletRequest request, HttpServletResponse response)
6539                    throws IOException, ServletException {
6540    
6541                    sendError(
6542                            HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
6543                            request, response);
6544            }
6545    
6546            @Override
6547            public void sendRSSFeedsDisabledError(
6548                            PortletRequest portletRequest, PortletResponse portletResponse)
6549                    throws IOException, ServletException {
6550    
6551                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6552                    HttpServletResponse response = getHttpServletResponse(portletResponse);
6553    
6554                    sendRSSFeedsDisabledError(request, response);
6555            }
6556    
6557            @Override
6558            public void setPageDescription(
6559                    String description, HttpServletRequest request) {
6560    
6561                    ListMergeable<String> descriptionListMergeable =
6562                            new ListMergeable<String>();
6563    
6564                    descriptionListMergeable.add(description);
6565    
6566                    request.setAttribute(
6567                            WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6568            }
6569    
6570            @Override
6571            public void setPageKeywords(String keywords, HttpServletRequest request) {
6572                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6573    
6574                    addPageKeywords(keywords, request);
6575            }
6576    
6577            @Override
6578            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6579                    ListMergeable<String> subtitleListMergeable =
6580                            new ListMergeable<String>();
6581    
6582                    subtitleListMergeable.add(subtitle);
6583    
6584                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6585            }
6586    
6587            @Override
6588            public void setPageTitle(String title, HttpServletRequest request) {
6589                    ListMergeable<String> titleListMergeable = new ListMergeable<String>();
6590    
6591                    titleListMergeable.add(title);
6592    
6593                    request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6594            }
6595    
6596            @Override
6597            public void setPortalPort(HttpServletRequest request) {
6598                    if (request.isSecure()) {
6599                            if (_securePortalPort.get() == -1) {
6600                                    int securePortalPort = request.getServerPort();
6601    
6602                                    _securePortalPort.compareAndSet(-1, securePortalPort);
6603                            }
6604                    }
6605                    else {
6606                            if (_portalPort.get() == -1) {
6607                                    int portalPort = request.getServerPort();
6608    
6609                                    if (_portalPort.compareAndSet(-1, portalPort)) {
6610                                            notifyPortalPortEventListeners(portalPort);
6611                                    }
6612                            }
6613                    }
6614            }
6615    
6616            @Override
6617            public void storePreferences(PortletPreferences portletPreferences)
6618                    throws IOException, ValidatorException {
6619    
6620                    PortletPreferencesWrapper portletPreferencesWrapper =
6621                            (PortletPreferencesWrapper)portletPreferences;
6622    
6623                    PortletPreferencesImpl portletPreferencesImpl =
6624                            portletPreferencesWrapper.getPortletPreferencesImpl();
6625    
6626                    portletPreferencesImpl.store();
6627            }
6628    
6629            @Override
6630            public String[] stripURLAnchor(String url, String separator) {
6631                    String anchor = StringPool.BLANK;
6632    
6633                    int pos = url.indexOf(separator);
6634    
6635                    if (pos != -1) {
6636                            anchor = url.substring(pos);
6637                            url = url.substring(0, pos);
6638                    }
6639    
6640                    return new String[] {url, anchor};
6641            }
6642    
6643            @Override
6644            public String transformCustomSQL(String sql) {
6645                    if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6646                            initCustomSQL();
6647                    }
6648    
6649                    return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6650            }
6651    
6652            @Override
6653            public String transformSQL(String sql) {
6654                    return SQLTransformer.transform(sql);
6655            }
6656    
6657            @Override
6658            public PortletMode updatePortletMode(
6659                    String portletId, User user, Layout layout, PortletMode portletMode,
6660                    HttpServletRequest request) {
6661    
6662                    LayoutTypePortlet layoutType =
6663                            (LayoutTypePortlet)layout.getLayoutType();
6664    
6665                    if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
6666                            if (layoutType.hasModeAboutPortletId(portletId)) {
6667                                    return LiferayPortletMode.ABOUT;
6668                            }
6669                            else if (layoutType.hasModeConfigPortletId(portletId)) {
6670                                    return LiferayPortletMode.CONFIG;
6671                            }
6672                            else if (layoutType.hasModeEditPortletId(portletId)) {
6673                                    return PortletMode.EDIT;
6674                            }
6675                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
6676                                    return LiferayPortletMode.EDIT_DEFAULTS;
6677                            }
6678                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
6679                                    return LiferayPortletMode.EDIT_GUEST;
6680                            }
6681                            else if (layoutType.hasModeHelpPortletId(portletId)) {
6682                                    return PortletMode.HELP;
6683                            }
6684                            else if (layoutType.hasModePreviewPortletId(portletId)) {
6685                                    return LiferayPortletMode.PREVIEW;
6686                            }
6687                            else if (layoutType.hasModePrintPortletId(portletId)) {
6688                                    return LiferayPortletMode.PRINT;
6689                            }
6690                            else {
6691                                    return PortletMode.VIEW;
6692                            }
6693                    }
6694                    else {
6695                            boolean updateLayout = false;
6696    
6697                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
6698                                    !layoutType.hasModeAboutPortletId(portletId)) {
6699    
6700                                    layoutType.addModeAboutPortletId(portletId);
6701    
6702                                    updateLayout = true;
6703                            }
6704                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
6705                                             !layoutType.hasModeConfigPortletId(portletId)) {
6706    
6707                                    layoutType.addModeConfigPortletId(portletId);
6708    
6709                                    updateLayout = true;
6710                            }
6711                            else if (portletMode.equals(PortletMode.EDIT) &&
6712                                             !layoutType.hasModeEditPortletId(portletId)) {
6713    
6714                                    layoutType.addModeEditPortletId(portletId);
6715    
6716                                    updateLayout = true;
6717                            }
6718                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
6719                                             !layoutType.hasModeEditDefaultsPortletId(portletId)) {
6720    
6721                                    layoutType.addModeEditDefaultsPortletId(portletId);
6722    
6723                                    updateLayout = true;
6724                            }
6725                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
6726                                             !layoutType.hasModeEditGuestPortletId(portletId)) {
6727    
6728                                    layoutType.addModeEditGuestPortletId(portletId);
6729    
6730                                    updateLayout = true;
6731                            }
6732                            else if (portletMode.equals(PortletMode.HELP) &&
6733                                             !layoutType.hasModeHelpPortletId(portletId)) {
6734    
6735                                    layoutType.addModeHelpPortletId(portletId);
6736    
6737                                    updateLayout = true;
6738                            }
6739                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
6740                                             !layoutType.hasModePreviewPortletId(portletId)) {
6741    
6742                                    layoutType.addModePreviewPortletId(portletId);
6743    
6744                                    updateLayout = true;
6745                            }
6746                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
6747                                             !layoutType.hasModePrintPortletId(portletId)) {
6748    
6749                                    layoutType.addModePrintPortletId(portletId);
6750    
6751                                    updateLayout = true;
6752                            }
6753                            else if (portletMode.equals(PortletMode.VIEW) &&
6754                                             !layoutType.hasModeViewPortletId(portletId)) {
6755    
6756                                    layoutType.removeModesPortletId(portletId);
6757    
6758                                    updateLayout = true;
6759                            }
6760    
6761                            if (updateLayout) {
6762                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6763    
6764                                    if (layoutClone != null) {
6765                                            layoutClone.update(
6766                                                    request, layout.getPlid(), layout.getTypeSettings());
6767                                    }
6768                            }
6769    
6770                            return portletMode;
6771                    }
6772            }
6773    
6774            @Override
6775            public String updateRedirect(
6776                    String redirect, String oldPath, String newPath) {
6777    
6778                    if (Validator.isNull(redirect) || (oldPath == null) ||
6779                            oldPath.equals(newPath)) {
6780    
6781                            return redirect;
6782                    }
6783    
6784                    String queryString = HttpUtil.getQueryString(redirect);
6785    
6786                    String redirectParam = HttpUtil.getParameter(
6787                            redirect, "redirect", false);
6788    
6789                    if (Validator.isNotNull(redirectParam)) {
6790                            String newRedirectParam = StringUtil.replace(
6791                                    redirectParam, HttpUtil.encodeURL(oldPath),
6792                                    HttpUtil.encodeURL(newPath));
6793    
6794                            queryString = StringUtil.replace(
6795                                    queryString, redirectParam, newRedirectParam);
6796                    }
6797    
6798                    String redirectPath = HttpUtil.getPath(redirect);
6799    
6800                    int pos = redirect.indexOf(redirectPath);
6801    
6802                    String prefix = redirect.substring(0, pos);
6803    
6804                    pos = redirectPath.lastIndexOf(oldPath);
6805    
6806                    if (pos != -1) {
6807                            prefix += redirectPath.substring(0, pos);
6808    
6809                            String suffix = redirectPath.substring(pos + oldPath.length());
6810    
6811                            redirect = prefix + newPath + suffix;
6812                    }
6813                    else {
6814                            redirect = prefix + redirectPath;
6815                    }
6816    
6817                    if (Validator.isNotNull(queryString)) {
6818                            redirect += StringPool.QUESTION + queryString;
6819                    }
6820    
6821                    return redirect;
6822            }
6823    
6824            @Override
6825            public WindowState updateWindowState(
6826                    String portletId, User user, Layout layout, WindowState windowState,
6827                    HttpServletRequest request) {
6828    
6829                    LayoutTypePortlet layoutType =
6830                            (LayoutTypePortlet)layout.getLayoutType();
6831    
6832                    if ((windowState == null) || Validator.isNull(windowState.toString())) {
6833                            if (layoutType.hasStateMaxPortletId(portletId)) {
6834                                    windowState = WindowState.MAXIMIZED;
6835                            }
6836                            else if (layoutType.hasStateMinPortletId(portletId)) {
6837                                    windowState = WindowState.MINIMIZED;
6838                            }
6839                            else {
6840                                    windowState = WindowState.NORMAL;
6841                            }
6842                    }
6843                    else {
6844                            boolean updateLayout = false;
6845    
6846                            if (windowState.equals(WindowState.MAXIMIZED) &&
6847                                    !layoutType.hasStateMaxPortletId(portletId)) {
6848    
6849                                    layoutType.addStateMaxPortletId(portletId);
6850    
6851                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
6852                                            updateLayout = true;
6853                                    }
6854                            }
6855                            else if (windowState.equals(WindowState.MINIMIZED) &&
6856                                             !layoutType.hasStateMinPortletId(portletId)) {
6857    
6858                                    layoutType.addStateMinPortletId(portletId);
6859    
6860                                    updateLayout = true;
6861                            }
6862                            else if (windowState.equals(WindowState.NORMAL) &&
6863                                             !layoutType.hasStateNormalPortletId(portletId)) {
6864    
6865                                    layoutType.removeStatesPortletId(portletId);
6866    
6867                                    updateLayout = true;
6868                            }
6869    
6870                            if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
6871                                    portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
6872    
6873                                    updateLayout = false;
6874                            }
6875    
6876                            if (updateLayout) {
6877                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6878    
6879                                    if (layoutClone != null) {
6880                                            layoutClone.update(
6881                                                    request, layout.getPlid(), layout.getTypeSettings());
6882                                    }
6883                            }
6884                    }
6885    
6886                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6887                            WebKeys.THEME_DISPLAY);
6888    
6889                    themeDisplay.setStateExclusive(
6890                            windowState.equals(LiferayWindowState.EXCLUSIVE));
6891                    themeDisplay.setStateMaximized(
6892                            windowState.equals(WindowState.MAXIMIZED));
6893                    themeDisplay.setStatePopUp(
6894                            windowState.equals(LiferayWindowState.POP_UP));
6895    
6896                    if (themeDisplay.isStateMaximized() &&
6897                            themeDisplay.isShowAddContentIcon()) {
6898    
6899                            themeDisplay.setShowAddContentIcon(false);
6900                    }
6901                    else if (!themeDisplay.isStateMaximized() &&
6902                                     !themeDisplay.isShowAddContentIcon() &&
6903                                     themeDisplay.isShowAddContentIconPermission()) {
6904    
6905                            themeDisplay.setShowAddContentIcon(true);
6906                    }
6907    
6908                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
6909    
6910                    return windowState;
6911            }
6912    
6913            protected void addDefaultResource(
6914                            long companyId, Layout layout, Portlet portlet,
6915                            boolean portletActions)
6916                    throws PortalException, SystemException {
6917    
6918                    long groupId = getScopeGroupId(layout, portlet.getPortletId());
6919    
6920                    addDefaultResource(companyId, groupId, layout, portlet, portletActions);
6921            }
6922    
6923            protected void addDefaultResource(
6924                            long companyId, long groupId, Layout layout, Portlet portlet,
6925                            boolean portletActions)
6926                    throws PortalException, SystemException {
6927    
6928                    String rootPortletId = portlet.getRootPortletId();
6929    
6930                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
6931                            layout.getPlid(), portlet.getPortletId());
6932    
6933                    String name = null;
6934                    String primaryKey = null;
6935    
6936                    if (portletActions) {
6937                            name = rootPortletId;
6938                            primaryKey = portletPrimaryKey;
6939                    }
6940                    else {
6941                            Group group = GroupLocalServiceUtil.fetchGroup(groupId);
6942    
6943                            if ((group != null) && group.isStagingGroup()) {
6944                                    groupId = group.getLiveGroupId();
6945                            }
6946    
6947                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
6948                            primaryKey = String.valueOf(groupId);
6949                    }
6950    
6951                    if (Validator.isNull(name)) {
6952                            return;
6953                    }
6954    
6955                    int count =
6956                            ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
6957                                    companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
6958                                    primaryKey);
6959    
6960                    if (count > 0) {
6961                            return;
6962                    }
6963    
6964                    boolean addGuestPermissions = true;
6965    
6966                    if (portletActions) {
6967                            Group layoutGroup = layout.getGroup();
6968    
6969                            if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype()) {
6970                                    addGuestPermissions = false;
6971                            }
6972                    }
6973    
6974                    ResourceLocalServiceUtil.addResources(
6975                            companyId, groupId, 0, name, primaryKey, portletActions, true,
6976                            addGuestPermissions);
6977            }
6978    
6979            protected String buildI18NPath(Locale locale) {
6980                    String languageId = LocaleUtil.toLanguageId(locale);
6981    
6982                    if (Validator.isNull(languageId)) {
6983                            return null;
6984                    }
6985    
6986                    if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
6987                            Locale priorityLocale = LanguageUtil.getLocale(
6988                                    locale.getLanguage());
6989    
6990                            if (locale.equals(priorityLocale)) {
6991                                    languageId = locale.getLanguage();
6992                            }
6993                    }
6994                    else {
6995                            languageId = locale.getLanguage();
6996                    }
6997    
6998                    return StringPool.SLASH.concat(languageId);
6999            }
7000    
7001            protected long doGetPlidFromPortletId(
7002                            long groupId, boolean privateLayout, String portletId)
7003                    throws PortalException, SystemException {
7004    
7005                    long scopeGroupId = groupId;
7006    
7007                    try {
7008                            Group group = GroupLocalServiceUtil.getGroup(groupId);
7009    
7010                            if (group.isLayout()) {
7011                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7012                                            group.getClassPK());
7013    
7014                                    groupId = scopeLayout.getGroupId();
7015                            }
7016                    }
7017                    catch (Exception e) {
7018                    }
7019    
7020                    long plid = LayoutConstants.DEFAULT_PLID;
7021    
7022                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7023                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7024    
7025                    for (Layout layout : layouts) {
7026                            LayoutTypePortlet layoutTypePortlet =
7027                                    (LayoutTypePortlet)layout.getLayoutType();
7028    
7029                            if (layoutTypePortlet.hasPortletId(portletId, true)) {
7030                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7031                                            plid = layout.getPlid();
7032    
7033                                            break;
7034                                    }
7035                            }
7036                    }
7037    
7038                    return plid;
7039            }
7040    
7041            protected List<Portlet> filterControlPanelPortlets(
7042                    Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7043    
7044                    List<Portlet> filteredPortlets = new ArrayList<Portlet>(portlets);
7045    
7046                    Iterator<Portlet> itr = filteredPortlets.iterator();
7047    
7048                    while (itr.hasNext()) {
7049                            Portlet portlet = itr.next();
7050    
7051                            try {
7052                                    if (!portlet.isActive() || portlet.isInstanceable() ||
7053                                            !PortletPermissionUtil.hasControlPanelAccessPermission(
7054                                                    themeDisplay.getPermissionChecker(),
7055                                                    themeDisplay.getScopeGroupId(), portlet)) {
7056    
7057                                            itr.remove();
7058                                    }
7059                            }
7060                            catch (Exception e) {
7061                                    _log.error(e, e);
7062    
7063                                    itr.remove();
7064                            }
7065                    }
7066    
7067                    return filteredPortlets;
7068            }
7069    
7070            protected Locale getAvailableLocale(long groupId, Locale locale) {
7071                    if (Validator.isNull(locale.getCountry())) {
7072    
7073                            // Locales must contain a country code
7074    
7075                            locale = LanguageUtil.getLocale(locale.getLanguage());
7076                    }
7077    
7078                    if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7079                            return null;
7080                    }
7081    
7082                    return locale;
7083            }
7084    
7085            protected String getCanonicalDomain(
7086                    boolean canonicalURL, String virtualHostname, String portalDomain) {
7087    
7088                    if (!canonicalURL || Validator.isBlank(portalDomain)) {
7089                            return virtualHostname;
7090                    }
7091    
7092                    int pos = portalDomain.indexOf(CharPool.COLON);
7093    
7094                    if (pos != -1) {
7095                            portalDomain = portalDomain.substring(0, pos);
7096                    }
7097    
7098                    if (!StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) &&
7099                            StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7100    
7101                            virtualHostname = portalDomain;
7102                    }
7103    
7104                    return virtualHostname;
7105            }
7106    
7107            protected Map<String, List<Portlet>> getCategoriesMap(
7108                            HttpServletRequest request, String attributeName,
7109                            String[] categories)
7110                    throws SystemException {
7111    
7112                    Map<String, List<Portlet>> categoriesMap =
7113                            (Map<String, List<Portlet>>)request.getAttribute(attributeName);
7114    
7115                    if (categoriesMap != null) {
7116                            return categoriesMap;
7117                    }
7118    
7119                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7120                            WebKeys.THEME_DISPLAY);
7121    
7122                    categoriesMap = new LinkedHashMap<String, List<Portlet>>();
7123    
7124                    for (String category : categories) {
7125                            List<Portlet> portlets = getControlPanelPortlets(
7126                                    category, themeDisplay);
7127    
7128                            if (!portlets.isEmpty()) {
7129                                    categoriesMap.put(category, portlets);
7130                            }
7131                    }
7132    
7133                    request.setAttribute(attributeName, categoriesMap);
7134    
7135                    return categoriesMap;
7136            }
7137    
7138            protected long getDefaultScopeGroupId(long companyId)
7139                    throws PortalException, SystemException {
7140    
7141                    long doAsGroupId = 0;
7142    
7143                    Collection<Portlet> portlets = getControlPanelPortlets(
7144                            companyId, PortletCategoryKeys.SITE_ADMINISTRATION);
7145    
7146                    List<Group> groups = GroupServiceUtil.getManageableSiteGroups(
7147                            portlets, 1);
7148    
7149                    if (!groups.isEmpty()) {
7150                            Group group = groups.get(0);
7151    
7152                            doAsGroupId = group.getGroupId();
7153                    }
7154                    else {
7155                            Group guestGroup = GroupLocalServiceUtil.fetchGroup(
7156                                    companyId, GroupConstants.GUEST);
7157    
7158                            if (guestGroup != null) {
7159                                    doAsGroupId = guestGroup.getGroupId();
7160                            }
7161                    }
7162    
7163                    return doAsGroupId;
7164            }
7165    
7166            protected long getDoAsUserId(
7167                            HttpServletRequest request, String doAsUserIdString,
7168                            boolean alwaysAllowDoAsUser)
7169                    throws Exception {
7170    
7171                    if (Validator.isNull(doAsUserIdString)) {
7172                            return 0;
7173                    }
7174    
7175                    long doAsUserId = 0;
7176    
7177                    try {
7178                            Company company = getCompany(request);
7179    
7180                            doAsUserId = GetterUtil.getLong(
7181                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7182                    }
7183                    catch (Exception e) {
7184                            if (_log.isWarnEnabled()) {
7185                                    _log.warn(
7186                                            "Unable to impersonate " + doAsUserIdString +
7187                                                    " because the string cannot be decrypted");
7188                            }
7189    
7190                            return 0;
7191                    }
7192    
7193                    if (_log.isDebugEnabled()) {
7194                            if (alwaysAllowDoAsUser) {
7195                                    _log.debug(
7196                                            "doAsUserId path or Struts action is always allowed");
7197                            }
7198                            else {
7199                                    _log.debug(
7200                                            "doAsUserId path is Struts action not always allowed");
7201                            }
7202                    }
7203    
7204                    if (alwaysAllowDoAsUser) {
7205                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7206    
7207                            return doAsUserId;
7208                    }
7209    
7210                    HttpSession session = request.getSession();
7211    
7212                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7213    
7214                    if (realUserIdObj == null) {
7215                            return 0;
7216                    }
7217    
7218                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7219    
7220                    long[] organizationIds = doAsUser.getOrganizationIds();
7221    
7222                    User realUser = UserLocalServiceUtil.getUserById(
7223                            realUserIdObj.longValue());
7224    
7225                    PermissionChecker permissionChecker =
7226                            PermissionCheckerFactoryUtil.create(realUser);
7227    
7228                    if (doAsUser.isDefaultUser() ||
7229                            UserPermissionUtil.contains(
7230                                    permissionChecker, doAsUserId, organizationIds,
7231                                    ActionKeys.IMPERSONATE)) {
7232    
7233                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7234    
7235                            return doAsUserId;
7236                    }
7237    
7238                    _log.error(
7239                            "User " + realUserIdObj + " does not have the permission to " +
7240                                    "impersonate " + doAsUserId);
7241    
7242                    return 0;
7243            }
7244    
7245            protected String getGroupFriendlyURL(
7246                            Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
7247                            boolean canonicalURL)
7248                    throws PortalException, SystemException {
7249    
7250                    LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7251                            group.getGroupId(), privateLayoutSet);
7252    
7253                    String portalURL = themeDisplay.getPortalURL();
7254    
7255                    if (canonicalURL || !themeDisplay.getServerName().equals(_LOCALHOST)) {
7256                            String virtualHostname = layoutSet.getVirtualHostname();
7257    
7258                            if (Validator.isNull(virtualHostname) &&
7259                                    Validator.isNotNull(
7260                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
7261                                    !layoutSet.isPrivateLayout()) {
7262    
7263                                    try {
7264                                            Group defaultGroup = GroupLocalServiceUtil.getGroup(
7265                                                    themeDisplay.getCompanyId(),
7266                                                    PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
7267    
7268                                            if (layoutSet.getGroupId() == defaultGroup.getGroupId()) {
7269                                                    Company company = themeDisplay.getCompany();
7270    
7271                                                    virtualHostname = company.getVirtualHostname();
7272                                            }
7273                                    }
7274                                    catch (Exception e) {
7275                                            _log.error(e, e);
7276                                    }
7277                            }
7278    
7279                            String portalDomain = HttpUtil.getDomain(portalURL);
7280    
7281                            if (Validator.isNotNull(virtualHostname) &&
7282                                    (canonicalURL ||
7283                                     !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7284    
7285                                    virtualHostname = getCanonicalDomain(
7286                                            canonicalURL, virtualHostname, portalDomain);
7287    
7288                                    virtualHostname = getPortalURL(
7289                                            virtualHostname, themeDisplay.getServerPort(),
7290                                            themeDisplay.isSecure());
7291    
7292                                    if (canonicalURL || virtualHostname.contains(portalDomain)) {
7293                                            String path = StringPool.BLANK;
7294    
7295                                            if (themeDisplay.isWidget()) {
7296                                                    path = PropsValues.WIDGET_SERVLET_MAPPING;
7297                                            }
7298    
7299                                            if (themeDisplay.isI18n() && !canonicalURL) {
7300                                                    path = themeDisplay.getI18nPath();
7301                                            }
7302    
7303                                            return virtualHostname.concat(_pathContext).concat(path);
7304                                    }
7305                            }
7306                            else {
7307                                    LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7308                                            themeDisplay.getSiteGroupId(), privateLayoutSet);
7309    
7310                                    if (canonicalURL ||
7311                                            ((layoutSet.getLayoutSetId() !=
7312                                                    curLayoutSet.getLayoutSetId()) &&
7313                                             (group.getClassPK() != themeDisplay.getUserId()))) {
7314    
7315                                            if (group.isControlPanel()) {
7316                                                    virtualHostname = themeDisplay.getServerName();
7317    
7318                                                    if (Validator.isNull(virtualHostname) ||
7319                                                            StringUtil.equalsIgnoreCase(
7320                                                                    virtualHostname, _LOCALHOST)) {
7321    
7322                                                            virtualHostname = curLayoutSet.getVirtualHostname();
7323                                                    }
7324                                            }
7325    
7326                                            if (Validator.isNull(virtualHostname) ||
7327                                                    StringUtil.equalsIgnoreCase(
7328                                                            virtualHostname, _LOCALHOST)) {
7329    
7330                                                    Company company = themeDisplay.getCompany();
7331    
7332                                                    virtualHostname = company.getVirtualHostname();
7333                                            }
7334    
7335                                            if (canonicalURL ||
7336                                                    !StringUtil.equalsIgnoreCase(
7337                                                            virtualHostname, _LOCALHOST)) {
7338    
7339                                                    virtualHostname = getCanonicalDomain(
7340                                                            canonicalURL, virtualHostname, portalDomain);
7341    
7342                                                    portalURL = getPortalURL(
7343                                                            virtualHostname, themeDisplay.getServerPort(),
7344                                                            themeDisplay.isSecure());
7345                                            }
7346                                    }
7347                            }
7348                    }
7349    
7350                    String friendlyURL = null;
7351    
7352                    if (privateLayoutSet) {
7353                            if (group.isUser()) {
7354                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7355                            }
7356                            else {
7357                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7358                            }
7359                    }
7360                    else {
7361                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7362                    }
7363    
7364                    StringBundler sb = new StringBundler(6);
7365    
7366                    sb.append(portalURL);
7367                    sb.append(_pathContext);
7368    
7369                    if (themeDisplay.isI18n() && !canonicalURL) {
7370                            sb.append(themeDisplay.getI18nPath());
7371                    }
7372    
7373                    if (themeDisplay.isWidget()) {
7374                            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7375                    }
7376    
7377                    sb.append(friendlyURL);
7378                    sb.append(group.getFriendlyURL());
7379    
7380                    return sb.toString();
7381            }
7382    
7383            protected String getPortletParam(HttpServletRequest request, String name) {
7384                    String portletId = ParamUtil.getString(request, "p_p_id");
7385    
7386                    if (Validator.isNull(portletId)) {
7387                            return StringPool.BLANK;
7388                    }
7389    
7390                    String value = null;
7391    
7392                    int valueCount = 0;
7393    
7394                    String keyName = StringPool.UNDERLINE.concat(name);
7395    
7396                    Map<String, String[]> parameterMap = request.getParameterMap();
7397    
7398                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7399                            String parameterName = entry.getKey();
7400    
7401                            int pos = parameterName.indexOf(keyName);
7402    
7403                            if (pos == -1) {
7404                                    continue;
7405                            }
7406    
7407                            valueCount++;
7408    
7409                            // There should never be more than one value
7410    
7411                            if (valueCount > 1) {
7412                                    return StringPool.BLANK;
7413                            }
7414    
7415                            String[] parameterValues = entry.getValue();
7416    
7417                            if (ArrayUtil.isEmpty(parameterValues) ||
7418                                    Validator.isNull(parameterValues[0])) {
7419    
7420                                    continue;
7421                            }
7422    
7423                            // The Struts action must be for the correct portlet
7424    
7425                            String portletId1 = parameterName.substring(1, pos);
7426    
7427                            if (portletId.equals(portletId1)) {
7428                                    value = parameterValues[0];
7429                            }
7430                    }
7431    
7432                    if (value == null) {
7433                            value = StringPool.BLANK;
7434                    }
7435    
7436                    return value;
7437            }
7438    
7439            protected String getServletURL(
7440                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7441                    throws PortalException, SystemException {
7442    
7443                    Layout layout = themeDisplay.getLayout();
7444    
7445                    StringBundler sb = new StringBundler();
7446    
7447                    sb.append(themeDisplay.getPortalURL());
7448    
7449                    if (Validator.isNotNull(_pathContext)) {
7450                            sb.append(_pathContext);
7451                    }
7452    
7453                    if (themeDisplay.isI18n()) {
7454                            sb.append(themeDisplay.getI18nPath());
7455                    }
7456    
7457                    sb.append(servletPath);
7458    
7459                    Group group = layout.getGroup();
7460    
7461                    if (layout.isPrivateLayout()) {
7462                            if (group.isUser()) {
7463                                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7464                            }
7465                            else {
7466                                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7467                            }
7468                    }
7469                    else {
7470                            sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7471                    }
7472    
7473                    sb.append(group.getFriendlyURL());
7474                    sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7475    
7476                    sb.append(FRIENDLY_URL_SEPARATOR);
7477    
7478                    FriendlyURLMapper friendlyURLMapper =
7479                            portlet.getFriendlyURLMapperInstance();
7480    
7481                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7482                            sb.append(friendlyURLMapper.getMapping());
7483                    }
7484                    else {
7485                            sb.append(portlet.getPortletId());
7486                    }
7487    
7488                    return sb.toString();
7489            }
7490    
7491            protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7492                    throws Exception {
7493    
7494                    String ticketKey = ParamUtil.getString(request, "ticketKey");
7495    
7496                    if (Validator.isNull(ticketKey)) {
7497                            return false;
7498                    }
7499    
7500                    Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7501    
7502                    if ((ticket == null) ||
7503                            (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7504    
7505                            return false;
7506                    }
7507    
7508                    String className = ticket.getClassName();
7509    
7510                    if (!className.equals(User.class.getName())) {
7511                            return false;
7512                    }
7513    
7514                    long doAsUserId = 0;
7515    
7516                    try {
7517                            Company company = getCompany(request);
7518    
7519                            String doAsUserIdString = ParamUtil.getString(
7520                                    request, "doAsUserId");
7521    
7522                            if (Validator.isNotNull(doAsUserIdString)) {
7523                                    doAsUserId = GetterUtil.getLong(
7524                                            Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7525                            }
7526                    }
7527                    catch (Exception e) {
7528                            return false;
7529                    }
7530    
7531                    if (ticket.getClassPK() != doAsUserId) {
7532                            return false;
7533                    }
7534    
7535                    if (ticket.isExpired()) {
7536                            TicketLocalServiceUtil.deleteTicket(ticket);
7537    
7538                            return false;
7539                    }
7540    
7541                    Date expirationDate = new Date(
7542                            System.currentTimeMillis() +
7543                                    PropsValues.SESSION_TIMEOUT * Time.MINUTE);
7544    
7545                    ticket.setExpirationDate(expirationDate);
7546    
7547                    TicketLocalServiceUtil.updateTicket(ticket);
7548    
7549                    return true;
7550            }
7551    
7552            /**
7553             * @deprecated As of 6.2.0 with no direct replacement
7554             */
7555            protected boolean isPanelSelectedPortlet(
7556                    ThemeDisplay themeDisplay, String portletId) {
7557    
7558                    Layout layout = themeDisplay.getLayout();
7559    
7560                    String panelSelectedPortlets = layout.getTypeSettingsProperty(
7561                            "panelSelectedPortlets");
7562    
7563                    if (Validator.isNotNull(panelSelectedPortlets)) {
7564                            String[] panelSelectedPortletsArray = StringUtil.split(
7565                                    panelSelectedPortlets);
7566    
7567                            return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
7568                    }
7569    
7570                    return false;
7571            }
7572    
7573            protected void notifyPortalPortEventListeners(int portalPort) {
7574                    for (PortalPortEventListener portalPortEventListener :
7575                                    _portalPortEventListeners) {
7576    
7577                            portalPortEventListener.portalPortConfigured(portalPort);
7578                    }
7579            }
7580    
7581            protected String removeRedirectParameter(String url) {
7582                    String queryString = HttpUtil.getQueryString(url);
7583    
7584                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
7585                            queryString);
7586    
7587                    for (String parameter : parameterMap.keySet()) {
7588                            if (parameter.endsWith("redirect")) {
7589                                    url = HttpUtil.removeParameter(url, parameter);
7590                            }
7591                    }
7592    
7593                    return url;
7594            }
7595    
7596            protected void resetThemeDisplayI18n(
7597                    ThemeDisplay themeDisplay, String languageId, String path) {
7598    
7599                    themeDisplay.setI18nLanguageId(languageId);
7600                    themeDisplay.setI18nPath(path);
7601            }
7602    
7603            protected void setLocale(
7604                    HttpServletRequest request, HttpServletResponse response,
7605                    Locale locale) {
7606    
7607                    HttpSession session = request.getSession();
7608    
7609                    session.setAttribute(Globals.LOCALE_KEY, locale);
7610    
7611                    LanguageUtil.updateCookie(request, response, locale);
7612            }
7613    
7614            protected void setThemeDisplayI18n(
7615                    ThemeDisplay themeDisplay, Locale locale) {
7616    
7617                    String i18nLanguageId = null;
7618                    String i18nPath = null;
7619    
7620                    if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
7621                             ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
7622                              !locale.equals(LocaleUtil.getDefault()))) ||
7623                            (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
7624    
7625                            i18nLanguageId = locale.toString();
7626                            i18nPath = buildI18NPath(locale);
7627                    }
7628    
7629                    themeDisplay.setI18nLanguageId(i18nLanguageId);
7630                    themeDisplay.setI18nPath(i18nPath);
7631            }
7632    
7633            private static final String _J_SECURITY_CHECK = "j_security_check";
7634    
7635            private static final String _JSESSIONID = ";jsessionid=";
7636    
7637            private static final String _LOCALHOST = "localhost";
7638    
7639            private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
7640                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
7641    
7642            private static final String _PRIVATE_USER_SERVLET_MAPPING =
7643                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
7644    
7645            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
7646                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
7647    
7648            private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
7649    
7650            private static Log _logWebServerServlet = LogFactoryUtil.getLog(
7651                    WebServerServlet.class);
7652    
7653            private static Map<Long, String> _cdnHostHttpMap =
7654                    new ConcurrentHashMap<Long, String>();
7655            private static Map<Long, String> _cdnHostHttpsMap =
7656                    new ConcurrentHashMap<Long, String>();
7657            private static MethodHandler _resetCDNHostsMethodHandler =
7658                    new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
7659            private static Date _upTime = new Date();
7660    
7661            private String[] _allSystemGroups;
7662            private String[] _allSystemOrganizationRoles;
7663            private String[] _allSystemRoles;
7664            private String[] _allSystemSiteRoles;
7665            private Pattern _bannedResourceIdPattern = Pattern.compile(
7666                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
7667                    Pattern.CASE_INSENSITIVE);
7668            private String _computerAddress;
7669            private String _computerName;
7670            private String[] _customSqlKeys;
7671            private String[] _customSqlValues;
7672            private EditDiscussionAction _editDiscussionAction =
7673                    new EditDiscussionAction();
7674            private String _pathContext;
7675            private String _pathFriendlyURLPrivateGroup;
7676            private String _pathFriendlyURLPrivateUser;
7677            private String _pathFriendlyURLPublic;
7678            private String _pathImage;
7679            private String _pathMain;
7680            private String _pathModule;
7681            private String _pathProxy;
7682            private Map<String, Long> _plidToPortletIdMap =
7683                    new ConcurrentHashMap<String, Long>();
7684            private final AtomicInteger _portalPort = new AtomicInteger(-1);
7685            private List<PortalPortEventListener> _portalPortEventListeners =
7686                    new ArrayList<PortalPortEventListener>();
7687            private Set<String> _reservedParams;
7688            private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
7689            private final String _servletContextName;
7690            private String[] _sortedSystemGroups;
7691            private String[] _sortedSystemOrganizationRoles;
7692            private String[] _sortedSystemRoles;
7693            private String[] _sortedSystemSiteRoles;
7694    
7695    }