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