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