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