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