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