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