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