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