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