001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.util;
016    
017    import com.liferay.portal.RSSFeedException;
018    import com.liferay.portal.comment.action.EditDiscussionStrutsAction;
019    import com.liferay.portal.comment.action.GetCommentsStrutsAction;
020    import com.liferay.portal.dao.orm.common.SQLTransformer;
021    import com.liferay.portal.events.StartupHelperUtil;
022    import com.liferay.portal.exception.ImageTypeException;
023    import com.liferay.portal.exception.NoSuchGroupException;
024    import com.liferay.portal.exception.NoSuchImageException;
025    import com.liferay.portal.exception.NoSuchLayoutException;
026    import com.liferay.portal.exception.NoSuchUserException;
027    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
028    import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
029    import com.liferay.portal.kernel.cluster.ClusterInvokeThreadLocal;
030    import com.liferay.portal.kernel.cluster.ClusterRequest;
031    import com.liferay.portal.kernel.concurrent.ConcurrentHashSet;
032    import com.liferay.portal.kernel.dao.db.DB;
033    import com.liferay.portal.kernel.dao.db.DBManagerUtil;
034    import com.liferay.portal.kernel.dao.jdbc.DataAccess;
035    import com.liferay.portal.kernel.dao.orm.QueryUtil;
036    import com.liferay.portal.kernel.exception.PortalException;
037    import com.liferay.portal.kernel.exception.SystemException;
038    import com.liferay.portal.kernel.image.ImageBag;
039    import com.liferay.portal.kernel.image.ImageToolUtil;
040    import com.liferay.portal.kernel.language.LanguageUtil;
041    import com.liferay.portal.kernel.log.Log;
042    import com.liferay.portal.kernel.log.LogFactoryUtil;
043    import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
044    import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
045    import com.liferay.portal.kernel.portlet.FriendlyURLResolver;
046    import com.liferay.portal.kernel.portlet.FriendlyURLResolverRegistryUtil;
047    import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
048    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
049    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
050    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
051    import com.liferay.portal.kernel.portlet.LiferayPortletURL;
052    import com.liferay.portal.kernel.portlet.LiferayWindowState;
053    import com.liferay.portal.kernel.portlet.PortletBag;
054    import com.liferay.portal.kernel.portlet.PortletBagPool;
055    import com.liferay.portal.kernel.security.auth.AlwaysAllowDoAsUser;
056    import com.liferay.portal.kernel.security.auth.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.exception.ImageSizeException;
203    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
204    import com.liferay.portlet.documentlibrary.model.DLFolder;
205    import com.liferay.portlet.expando.exception.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.social.model.SocialRelationConstants;
211    import com.liferay.portlet.social.util.FacebookUtil;
212    import com.liferay.registry.Registry;
213    import com.liferay.registry.RegistryUtil;
214    import com.liferay.registry.ServiceReference;
215    import com.liferay.registry.ServiceTracker;
216    import com.liferay.registry.ServiceTrackerCustomizer;
217    import com.liferay.sites.kernel.util.Sites;
218    import com.liferay.sites.kernel.util.SitesUtil;
219    import com.liferay.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.isWarnEnabled()) {
882                                                    _log.warn("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.isWarnEnabled()) {
911                                            _log.warn("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 getLayoutSetDisplayURL(
2955                            LayoutSet layoutSet, boolean secureConnection)
2956                    throws PortalException {
2957    
2958                    Company company = CompanyLocalServiceUtil.getCompany(
2959                            layoutSet.getCompanyId());
2960                    int portalPort = getPortalServerPort(secureConnection);
2961    
2962                    String portalURL = getPortalURL(
2963                            company.getVirtualHostname(), portalPort, secureConnection);
2964    
2965                    String virtualHostname = getVirtualHostname(layoutSet);
2966    
2967                    if (Validator.isNotNull(virtualHostname) &&
2968                            !StringUtil.equalsIgnoreCase(virtualHostname, "localhost")) {
2969    
2970                            String portalDomain = HttpUtil.getDomain(portalURL);
2971    
2972                            virtualHostname = getCanonicalDomain(virtualHostname, portalDomain);
2973    
2974                            virtualHostname = getPortalURL(
2975                                    virtualHostname, portalPort, secureConnection);
2976    
2977                            if (virtualHostname.contains(portalDomain)) {
2978                                    return virtualHostname.concat(getPathContext());
2979                            }
2980                    }
2981    
2982                    StringBundler sb = new StringBundler(4);
2983    
2984                    sb.append(portalURL);
2985                    sb.append(getPathContext());
2986    
2987                    Group group = layoutSet.getGroup();
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                    sb.append(friendlyURL);
3004    
3005                    sb.append(group.getFriendlyURL());
3006    
3007                    return sb.toString();
3008            }
3009    
3010            @Override
3011            public String getLayoutSetFriendlyURL(
3012                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
3013                    throws PortalException {
3014    
3015                    String virtualHostname = getVirtualHostname(layoutSet);
3016    
3017                    if (Validator.isNotNull(virtualHostname) &&
3018                            !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
3019    
3020                            String portalURL = getPortalURL(
3021                                    virtualHostname, themeDisplay.getServerPort(),
3022                                    themeDisplay.isSecure());
3023    
3024                            // Use the layout set's virtual host setting only if the layout set
3025                            // is already used for the current request
3026    
3027                            long curLayoutSetId =
3028                                    themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
3029    
3030                            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
3031                                    portalURL.startsWith(themeDisplay.getURLPortal())) {
3032    
3033                                    String layoutSetFriendlyURL = portalURL + _pathContext;
3034    
3035                                    if (themeDisplay.isI18n()) {
3036                                            layoutSetFriendlyURL += themeDisplay.getI18nPath();
3037                                    }
3038    
3039                                    return addPreservedParameters(
3040                                            themeDisplay, layoutSetFriendlyURL);
3041                            }
3042                    }
3043    
3044                    Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
3045    
3046                    String friendlyURL = null;
3047    
3048                    if (layoutSet.isPrivateLayout()) {
3049                            if (group.isUser()) {
3050                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
3051                            }
3052                            else {
3053                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
3054                            }
3055                    }
3056                    else {
3057                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
3058                    }
3059    
3060                    if (themeDisplay.isI18n()) {
3061                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
3062                    }
3063    
3064                    String layoutSetFriendlyURL =
3065                            _pathContext + friendlyURL + group.getFriendlyURL();
3066    
3067                    return addPreservedParameters(themeDisplay, layoutSetFriendlyURL);
3068            }
3069    
3070            @Override
3071            public String getLayoutTarget(Layout layout) {
3072                    UnicodeProperties typeSettingsProps =
3073                            layout.getTypeSettingsProperties();
3074    
3075                    String target = typeSettingsProps.getProperty("target");
3076    
3077                    if (Validator.isNull(target)) {
3078                            target = StringPool.BLANK;
3079                    }
3080                    else {
3081                            target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
3082                    }
3083    
3084                    return target;
3085            }
3086    
3087            @Override
3088            public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
3089                    throws PortalException {
3090    
3091                    return getLayoutURL(layout, themeDisplay, true);
3092            }
3093    
3094            @Override
3095            public String getLayoutURL(
3096                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
3097                    throws PortalException {
3098    
3099                    if (layout == null) {
3100                            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
3101                    }
3102    
3103                    if (!layout.isTypeURL()) {
3104                            String layoutFriendlyURL = getLayoutFriendlyURL(
3105                                    layout, themeDisplay);
3106    
3107                            if (Validator.isNotNull(layoutFriendlyURL)) {
3108                                    layoutFriendlyURL = addPreservedParameters(
3109                                            themeDisplay, layout, layoutFriendlyURL, doAsUser);
3110    
3111                                    return layoutFriendlyURL;
3112                            }
3113                    }
3114    
3115                    String layoutURL = getLayoutActualURL(layout);
3116    
3117                    layoutURL = addPreservedParameters(
3118                            themeDisplay, layout, layoutURL, doAsUser);
3119    
3120                    return layoutURL;
3121            }
3122    
3123            @Override
3124            public String getLayoutURL(
3125                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
3126                    throws PortalException {
3127    
3128                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
3129                    String i18nPath = themeDisplay.getI18nPath();
3130                    Locale originalLocale = themeDisplay.getLocale();
3131    
3132                    try {
3133                            setThemeDisplayI18n(themeDisplay, locale);
3134    
3135                            return getLayoutURL(layout, themeDisplay, true);
3136                    }
3137                    finally {
3138                            resetThemeDisplayI18n(
3139                                    themeDisplay, i18nLanguageId, i18nPath, originalLocale);
3140                    }
3141            }
3142    
3143            @Override
3144            public String getLayoutURL(ThemeDisplay themeDisplay)
3145                    throws PortalException {
3146    
3147                    return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
3148            }
3149    
3150            @Override
3151            public LiferayPortletRequest getLiferayPortletRequest(
3152                    PortletRequest portletRequest) {
3153    
3154                    if (portletRequest instanceof LiferayPortletRequest) {
3155                            return (LiferayPortletRequest)portletRequest;
3156                    }
3157    
3158                    PortletRequestImpl portletRequestImpl =
3159                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
3160    
3161                    return DoPrivilegedUtil.wrapWhenActive(portletRequestImpl);
3162            }
3163    
3164            @Override
3165            public LiferayPortletResponse getLiferayPortletResponse(
3166                    PortletResponse portletResponse) {
3167    
3168                    if (portletResponse instanceof LiferayPortletResponse) {
3169                            return (LiferayPortletResponse)portletResponse;
3170                    }
3171    
3172                    PortletResponseImpl portletResponseImpl =
3173                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
3174    
3175                    return DoPrivilegedUtil.wrapWhenActive(portletResponseImpl);
3176            }
3177    
3178            @Override
3179            public Locale getLocale(HttpServletRequest request) {
3180                    return getLocale(request, null, false);
3181            }
3182    
3183            @Override
3184            public Locale getLocale(
3185                    HttpServletRequest request, HttpServletResponse response,
3186                    boolean initialize) {
3187    
3188                    User user = null;
3189    
3190                    if (initialize) {
3191                            try {
3192                                    user = initUser(request);
3193                            }
3194                            catch (NoSuchUserException nsue) {
3195                                    return null;
3196                            }
3197                            catch (Exception e) {
3198                            }
3199                    }
3200    
3201                    Locale locale = null;
3202    
3203                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3204                            WebKeys.THEME_DISPLAY);
3205    
3206                    if (themeDisplay != null) {
3207                            locale = themeDisplay.getLocale();
3208    
3209                            if (LanguageUtil.isAvailableLocale(
3210                                            themeDisplay.getSiteGroupId(), locale)) {
3211    
3212                                    return locale;
3213                            }
3214                    }
3215    
3216                    long groupId = 0;
3217    
3218                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3219    
3220                    if ((layout != null) && !layout.isTypeControlPanel()) {
3221                            try {
3222                                    long scopeGroupId = getScopeGroupId(request);
3223    
3224                                    groupId = getSiteGroupId(scopeGroupId);
3225                            }
3226                            catch (Exception e) {
3227                            }
3228                    }
3229    
3230                    String i18nLanguageId = (String)request.getAttribute(
3231                            WebKeys.I18N_LANGUAGE_ID);
3232    
3233                    if (Validator.isNotNull(i18nLanguageId)) {
3234                            locale = LocaleUtil.fromLanguageId(i18nLanguageId);
3235    
3236                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3237                                    return locale;
3238                            }
3239                            else if (groupId > 0) {
3240                                    boolean inheritLocales = true;
3241    
3242                                    try {
3243                                            inheritLocales = LanguageUtil.isInheritLocales(groupId);
3244                                    }
3245                                    catch (PortalException pe) {
3246                                            _log.error(pe);
3247                                    }
3248    
3249                                    if (!inheritLocales) {
3250                                            String i18nLanguageCode = (String)request.getAttribute(
3251                                                    WebKeys.I18N_LANGUAGE_CODE);
3252    
3253                                            locale = LanguageUtil.getLocale(groupId, i18nLanguageCode);
3254    
3255                                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3256                                                    return locale;
3257                                            }
3258                                    }
3259                            }
3260                    }
3261    
3262                    String doAsUserLanguageId = ParamUtil.getString(
3263                            request, "doAsUserLanguageId");
3264    
3265                    if (Validator.isNotNull(doAsUserLanguageId)) {
3266                            locale = LocaleUtil.fromLanguageId(doAsUserLanguageId);
3267    
3268                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3269                                    return locale;
3270                            }
3271                    }
3272    
3273                    HttpSession session = request.getSession(false);
3274    
3275                    if ((session != null) &&
3276                            session.getAttribute(Globals.LOCALE_KEY) != null) {
3277    
3278                            locale = (Locale)session.getAttribute(Globals.LOCALE_KEY);
3279    
3280                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3281                                    return locale;
3282                            }
3283                    }
3284    
3285                    // Get locale from the user
3286    
3287                    if (user == null) {
3288                            try {
3289                                    user = getUser(request);
3290                            }
3291                            catch (Exception e) {
3292                            }
3293                    }
3294    
3295                    if ((user != null) && !user.isDefaultUser()) {
3296                            Locale userLocale = getAvailableLocale(groupId, user.getLocale());
3297    
3298                            if (LanguageUtil.isAvailableLocale(groupId, userLocale)) {
3299                                    if (initialize) {
3300                                            setLocale(request, response, userLocale);
3301                                    }
3302    
3303                                    return userLocale;
3304                            }
3305                    }
3306    
3307                    // Get locale from the cookie
3308    
3309                    String languageId = CookieKeys.getCookie(
3310                            request, CookieKeys.GUEST_LANGUAGE_ID, false);
3311    
3312                    if (Validator.isNotNull(languageId)) {
3313                            Locale cookieLocale = getAvailableLocale(
3314                                    groupId, LocaleUtil.fromLanguageId(languageId));
3315    
3316                            if (LanguageUtil.isAvailableLocale(groupId, cookieLocale)) {
3317                                    if (initialize) {
3318                                            setLocale(request, response, cookieLocale);
3319                                    }
3320    
3321                                    return cookieLocale;
3322                            }
3323                    }
3324    
3325                    // Get locale from the request
3326    
3327                    if (PropsValues.LOCALE_DEFAULT_REQUEST) {
3328                            Enumeration<Locale> locales = request.getLocales();
3329    
3330                            while (locales.hasMoreElements()) {
3331                                    Locale requestLocale = getAvailableLocale(
3332                                            groupId, locales.nextElement());
3333    
3334                                    if (LanguageUtil.isAvailableLocale(groupId, requestLocale)) {
3335                                            if (initialize) {
3336                                                    setLocale(request, response, requestLocale);
3337                                            }
3338    
3339                                            return requestLocale;
3340                                    }
3341                            }
3342                    }
3343    
3344                    // Get locale from the group
3345    
3346                    if (groupId > 0) {
3347                            try {
3348                                    Group group = GroupLocalServiceUtil.getGroup(groupId);
3349    
3350                                    UnicodeProperties typeSettingsProperties =
3351                                            group.getTypeSettingsProperties();
3352    
3353                                    String defaultLanguageId = typeSettingsProperties.getProperty(
3354                                            "languageId");
3355    
3356                                    if (Validator.isNotNull(defaultLanguageId)) {
3357                                            locale = LocaleUtil.fromLanguageId(defaultLanguageId);
3358    
3359                                            if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3360                                                    if (initialize) {
3361                                                            setLocale(request, response, locale);
3362                                                    }
3363    
3364                                                    return locale;
3365                                            }
3366                                    }
3367                            }
3368                            catch (Exception e) {
3369                            }
3370                    }
3371    
3372                    // Get locale from the default user
3373    
3374                    Company company = null;
3375    
3376                    try {
3377                            company = getCompany(request);
3378                    }
3379                    catch (Exception e) {
3380                    }
3381    
3382                    if (company == null) {
3383                            return null;
3384                    }
3385    
3386                    User defaultUser = null;
3387    
3388                    try {
3389                            defaultUser = company.getDefaultUser();
3390                    }
3391                    catch (Exception e) {
3392                    }
3393    
3394                    if (defaultUser == null) {
3395                            return null;
3396                    }
3397    
3398                    Locale defaultUserLocale = getAvailableLocale(
3399                            groupId, defaultUser.getLocale());
3400    
3401                    if (LanguageUtil.isAvailableLocale(groupId, defaultUserLocale)) {
3402                            if (initialize) {
3403                                    setLocale(request, response, defaultUserLocale);
3404                            }
3405    
3406                            return defaultUserLocale;
3407                    }
3408    
3409                    try {
3410                            if (themeDisplay != null) {
3411                                    return themeDisplay.getSiteDefaultLocale();
3412                            }
3413                    }
3414                    catch (Exception e) {
3415                    }
3416    
3417                    try {
3418                            return getSiteDefaultLocale(groupId);
3419                    }
3420                    catch (Exception e) {
3421                            return LocaleUtil.getDefault();
3422                    }
3423            }
3424    
3425            @Override
3426            public Locale getLocale(PortletRequest portletRequest) {
3427                    return getLocale(getHttpServletRequest(portletRequest));
3428            }
3429    
3430            @Override
3431            public String getLocalizedFriendlyURL(
3432                            HttpServletRequest request, Layout layout, Locale locale,
3433                            Locale originalLocale)
3434                    throws Exception {
3435    
3436                    String contextPath = getPathContext();
3437    
3438                    String requestURI = request.getRequestURI();
3439    
3440                    if (Validator.isNotNull(contextPath) &&
3441                            requestURI.contains(contextPath)) {
3442    
3443                            requestURI = requestURI.substring(contextPath.length());
3444                    }
3445    
3446                    requestURI = StringUtil.replace(
3447                            requestURI, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3448    
3449                    String path = request.getPathInfo();
3450    
3451                    int x = path.indexOf(CharPool.SLASH, 1);
3452    
3453                    String layoutFriendlyURL = null;
3454    
3455                    if (originalLocale == null) {
3456                            if ((x != -1) && ((x + 1) != path.length())) {
3457                                    layoutFriendlyURL = path.substring(x);
3458                            }
3459    
3460                            int y = layoutFriendlyURL.indexOf(
3461                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
3462    
3463                            if (y != -1) {
3464                                    y = layoutFriendlyURL.indexOf(CharPool.SLASH, 3);
3465    
3466                                    if ((y != -1) && ((y + 1) != layoutFriendlyURL.length())) {
3467                                            layoutFriendlyURL = layoutFriendlyURL.substring(y);
3468                                    }
3469                            }
3470    
3471                            y = layoutFriendlyURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
3472    
3473                            if (y != -1) {
3474                                    layoutFriendlyURL = layoutFriendlyURL.substring(0, y);
3475                            }
3476                    }
3477                    else {
3478                            layoutFriendlyURL = layout.getFriendlyURL(originalLocale);
3479                    }
3480    
3481                    String friendlyURL = StringPool.SLASH;
3482    
3483                    if (requestURI.contains(layoutFriendlyURL)) {
3484                            requestURI = StringUtil.replaceFirst(
3485                                    requestURI, layoutFriendlyURL, layout.getFriendlyURL(locale));
3486    
3487                            friendlyURL = layout.getFriendlyURL(locale);
3488                    }
3489    
3490                    LayoutSet layoutSet = layout.getLayoutSet();
3491    
3492                    String virtualHostname = layoutSet.getVirtualHostname();
3493    
3494                    String portalURL = getPortalURL(request);
3495    
3496                    if (Validator.isNull(virtualHostname) ||
3497                            !portalURL.contains(virtualHostname)) {
3498    
3499                            friendlyURL = requestURI;
3500                    }
3501    
3502                    String i18nPath =
3503                            StringPool.SLASH +
3504                                    getI18nPathLanguageId(locale, LocaleUtil.toLanguageId(locale));
3505    
3506                    boolean appendI18nPath = true;
3507    
3508                    if ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 0) ||
3509                            ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
3510                             locale.equals(LocaleUtil.getDefault()))) {
3511    
3512                            appendI18nPath = false;
3513                    }
3514    
3515                    String localizedFriendlyURL = contextPath;
3516    
3517                    if (appendI18nPath) {
3518                            localizedFriendlyURL += i18nPath;
3519                    }
3520    
3521                    localizedFriendlyURL += friendlyURL;
3522    
3523                    String queryString = request.getQueryString();
3524    
3525                    if (Validator.isNotNull(queryString)) {
3526                            localizedFriendlyURL +=
3527                                    StringPool.QUESTION + request.getQueryString();
3528                    }
3529    
3530                    return localizedFriendlyURL;
3531            }
3532    
3533            @Override
3534            public String getMailId(String mx, String popPortletPrefix, Object... ids) {
3535                    StringBundler sb = new StringBundler(ids.length * 2 + 7);
3536    
3537                    sb.append(StringPool.LESS_THAN);
3538                    sb.append(popPortletPrefix);
3539    
3540                    if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
3541                            sb.append(StringPool.PERIOD);
3542                    }
3543    
3544                    for (int i = 0; i < ids.length; i++) {
3545                            Object id = ids[i];
3546    
3547                            if (i != 0) {
3548                                    sb.append(StringPool.PERIOD);
3549                            }
3550    
3551                            sb.append(id);
3552                    }
3553    
3554                    sb.append(StringPool.AT);
3555    
3556                    if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
3557                            sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
3558                            sb.append(StringPool.PERIOD);
3559                    }
3560    
3561                    sb.append(mx);
3562                    sb.append(StringPool.GREATER_THAN);
3563    
3564                    return sb.toString();
3565            }
3566    
3567            @Override
3568            public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
3569                    throws PortalException {
3570    
3571                    return getServletURL(
3572                            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
3573            }
3574    
3575            @Override
3576            public String getNewPortletTitle(
3577                    String portletTitle, String oldScopeName, String newScopeName) {
3578    
3579                    if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
3580                            int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
3581    
3582                            portletTitle = portletTitle.substring(0, pos);
3583                    }
3584    
3585                    if (Validator.isNull(newScopeName)) {
3586                            return portletTitle;
3587                    }
3588    
3589                    return StringUtil.appendParentheticalSuffix(portletTitle, newScopeName);
3590            }
3591    
3592            @Override
3593            public HttpServletRequest getOriginalServletRequest(
3594                    HttpServletRequest request) {
3595    
3596                    List<PersistentHttpServletRequestWrapper>
3597                            persistentHttpServletRequestWrappers = new ArrayList<>();
3598    
3599                    HttpServletRequest originalRequest = request;
3600    
3601                    while (originalRequest instanceof HttpServletRequestWrapper) {
3602                            if (originalRequest instanceof
3603                                            PersistentHttpServletRequestWrapper) {
3604    
3605                                    PersistentHttpServletRequestWrapper
3606                                            persistentHttpServletRequestWrapper =
3607                                                    (PersistentHttpServletRequestWrapper)originalRequest;
3608    
3609                                    persistentHttpServletRequestWrappers.add(
3610                                            persistentHttpServletRequestWrapper.clone());
3611                            }
3612    
3613                            // Get original request so that portlets inside portlets render
3614                            // properly
3615    
3616                            HttpServletRequestWrapper httpServletRequestWrapper =
3617                                    (HttpServletRequestWrapper)originalRequest;
3618    
3619                            originalRequest =
3620                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
3621                    }
3622    
3623                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
3624                                    i--) {
3625    
3626                            HttpServletRequestWrapper httpServletRequestWrapper =
3627                                    persistentHttpServletRequestWrappers.get(i);
3628    
3629                            httpServletRequestWrapper.setRequest(originalRequest);
3630    
3631                            originalRequest = httpServletRequestWrapper;
3632                    }
3633    
3634                    return originalRequest;
3635            }
3636    
3637            /**
3638             * @deprecated As of 6.2.0 renamed to #getSiteGroupId(groupId)
3639             */
3640            @Deprecated
3641            @Override
3642            public long getParentGroupId(long groupId) {
3643                    return getSiteGroupId(groupId);
3644            }
3645    
3646            @Override
3647            public String getPathContext() {
3648                    return _pathContext;
3649            }
3650    
3651            @Override
3652            public String getPathContext(HttpServletRequest request) {
3653                    return getPathContext(request.getContextPath());
3654            }
3655    
3656            @Override
3657            public String getPathContext(PortletRequest portletRequest) {
3658                    return getPathContext(portletRequest.getContextPath());
3659            }
3660    
3661            @Override
3662            public String getPathContext(String contextPath) {
3663                    return _pathProxy.concat(getContextPath(contextPath));
3664            }
3665    
3666            @Override
3667            public String getPathFriendlyURLPrivateGroup() {
3668                    return _pathFriendlyURLPrivateGroup;
3669            }
3670    
3671            @Override
3672            public String getPathFriendlyURLPrivateUser() {
3673                    return _pathFriendlyURLPrivateUser;
3674            }
3675    
3676            @Override
3677            public String getPathFriendlyURLPublic() {
3678                    return _pathFriendlyURLPublic;
3679            }
3680    
3681            @Override
3682            public String getPathImage() {
3683                    return _pathImage;
3684            }
3685    
3686            @Override
3687            public String getPathMain() {
3688                    return _pathMain;
3689            }
3690    
3691            @Override
3692            public String getPathModule() {
3693                    return _pathModule;
3694            }
3695    
3696            @Override
3697            public String getPathProxy() {
3698                    return _pathProxy;
3699            }
3700    
3701            @Override
3702            public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
3703                    if (Validator.isNull(friendlyURL)) {
3704                            return LayoutConstants.DEFAULT_PLID;
3705                    }
3706    
3707                    String[] urlParts = friendlyURL.split("\\/", 4);
3708    
3709                    if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
3710                            (urlParts.length != 4)) {
3711    
3712                            return LayoutConstants.DEFAULT_PLID;
3713                    }
3714    
3715                    boolean privateLayout = true;
3716    
3717                    String urlPrefix = StringPool.SLASH + urlParts[1];
3718    
3719                    if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
3720                            privateLayout = false;
3721                    }
3722                    else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
3723                                     _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
3724    
3725                            privateLayout = true;
3726                    }
3727                    else {
3728                            return LayoutConstants.DEFAULT_PLID;
3729                    }
3730    
3731                    Group group = null;
3732    
3733                    try {
3734                            group = GroupLocalServiceUtil.getFriendlyURLGroup(
3735                                    companyId, StringPool.SLASH + urlParts[2]);
3736                    }
3737                    catch (Exception e) {
3738                    }
3739    
3740                    if (group == null) {
3741                            return LayoutConstants.DEFAULT_PLID;
3742                    }
3743    
3744                    Layout layout = null;
3745    
3746                    try {
3747                            String layoutFriendlyURL = null;
3748    
3749                            if (urlParts.length == 4) {
3750                                    layoutFriendlyURL = StringPool.SLASH + urlParts[3];
3751    
3752                                    layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3753                                            group.getGroupId(), privateLayout, layoutFriendlyURL);
3754                            }
3755                            else {
3756                                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3757                                            group.getGroupId(), privateLayout,
3758                                            LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
3759    
3760                                    if (!layouts.isEmpty()) {
3761                                            layout = layouts.get(0);
3762                                    }
3763                                    else {
3764                                            return LayoutConstants.DEFAULT_PLID;
3765                                    }
3766                            }
3767    
3768                            return layout.getPlid();
3769                    }
3770                    catch (Exception e) {
3771                    }
3772    
3773                    return LayoutConstants.DEFAULT_PLID;
3774            }
3775    
3776            @Override
3777            public long getPlidFromPortletId(
3778                    long groupId, boolean privateLayout, String portletId) {
3779    
3780                    long plid = LayoutConstants.DEFAULT_PLID;
3781    
3782                    StringBundler sb = new StringBundler(5);
3783    
3784                    sb.append(groupId);
3785                    sb.append(StringPool.SPACE);
3786                    sb.append(privateLayout);
3787                    sb.append(StringPool.SPACE);
3788                    sb.append(portletId);
3789    
3790                    String key = sb.toString();
3791    
3792                    Long plidObj = _plidToPortletIdMap.get(key);
3793    
3794                    if (plidObj == null) {
3795                            plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
3796    
3797                            if (plid != LayoutConstants.DEFAULT_PLID) {
3798                                    _plidToPortletIdMap.put(key, plid);
3799                            }
3800                    }
3801                    else {
3802                            plid = plidObj.longValue();
3803    
3804                            boolean validPlid = false;
3805    
3806                            try {
3807                                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
3808    
3809                                    LayoutTypePortlet layoutTypePortlet =
3810                                            (LayoutTypePortlet)layout.getLayoutType();
3811    
3812                                    if (layoutTypePortlet.hasDefaultScopePortletId(
3813                                                    groupId, portletId)) {
3814    
3815                                            validPlid = true;
3816                                    }
3817                            }
3818                            catch (Exception e) {
3819                            }
3820    
3821                            if (!validPlid) {
3822                                    _plidToPortletIdMap.remove(key);
3823    
3824                                    plid = doGetPlidFromPortletId(
3825                                            groupId, privateLayout, portletId);
3826    
3827                                    if (plid != LayoutConstants.DEFAULT_PLID) {
3828                                            _plidToPortletIdMap.put(key, plid);
3829                                    }
3830                            }
3831                    }
3832    
3833                    return plid;
3834            }
3835    
3836            @Override
3837            public long getPlidFromPortletId(long groupId, String portletId) {
3838                    long plid = getPlidFromPortletId(groupId, false, portletId);
3839    
3840                    if (plid == LayoutConstants.DEFAULT_PLID) {
3841                            plid = getPlidFromPortletId(groupId, true, portletId);
3842                    }
3843    
3844                    if (plid == LayoutConstants.DEFAULT_PLID) {
3845                            if (_log.isDebugEnabled()) {
3846                                    _log.debug(
3847                                            "Portlet " + portletId +
3848                                                    " does not exist on a page in group " + groupId);
3849                            }
3850                    }
3851    
3852                    return plid;
3853            }
3854    
3855            @Override
3856            public PortalInetSocketAddressEventListener[]
3857                    getPortalInetSocketAddressEventListeners() {
3858    
3859                    return _portalInetSocketAddressEventListeners.toArray(
3860                            new PortalInetSocketAddressEventListener[
3861                                    _portalInetSocketAddressEventListeners.size()]);
3862            }
3863    
3864            @Override
3865            public String getPortalLibDir() {
3866                    return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3867            }
3868    
3869            @Override
3870            public InetAddress getPortalLocalInetAddress(boolean secure) {
3871                    InetSocketAddress inetSocketAddress = null;
3872    
3873                    if (secure) {
3874                            inetSocketAddress = _securePortalLocalInetSocketAddress.get();
3875                    }
3876                    else {
3877                            inetSocketAddress = _portalLocalInetSocketAddress.get();
3878                    }
3879    
3880                    if (inetSocketAddress == null) {
3881                            return null;
3882                    }
3883    
3884                    return inetSocketAddress.getAddress();
3885            }
3886    
3887            @Override
3888            public int getPortalLocalPort(boolean secure) {
3889                    InetSocketAddress inetSocketAddress = null;
3890    
3891                    if (secure) {
3892                            inetSocketAddress = _securePortalLocalInetSocketAddress.get();
3893                    }
3894                    else {
3895                            inetSocketAddress = _portalLocalInetSocketAddress.get();
3896                    }
3897    
3898                    if (inetSocketAddress == null) {
3899                            return -1;
3900                    }
3901    
3902                    return inetSocketAddress.getPort();
3903            }
3904    
3905            /**
3906             * @deprecated As of 6.1.0, replaced by {@link #getPortalPort(boolean)}
3907             */
3908            @Deprecated
3909            @Override
3910            public int getPortalPort() {
3911                    return getPortalServerPort(false);
3912            }
3913    
3914            /**
3915             * @deprecated As of 7.0.0, replaced by {@link
3916             *             #getPortalServerPort(boolean)}
3917             */
3918            @Deprecated
3919            @Override
3920            public int getPortalPort(boolean secure) {
3921                    return getPortalServerPort(secure);
3922            }
3923    
3924            @Override
3925            public Properties getPortalProperties() {
3926                    return PropsUtil.getProperties();
3927            }
3928    
3929            @Override
3930            public InetAddress getPortalServerInetAddress(boolean secure) {
3931                    InetSocketAddress inetSocketAddress = null;
3932    
3933                    if (secure) {
3934                            inetSocketAddress = _securePortalServerInetSocketAddress.get();
3935                    }
3936                    else {
3937                            inetSocketAddress = _portalServerInetSocketAddress.get();
3938                    }
3939    
3940                    if (inetSocketAddress == null) {
3941                            return null;
3942                    }
3943    
3944                    return inetSocketAddress.getAddress();
3945            }
3946    
3947            @Override
3948            public int getPortalServerPort(boolean secure) {
3949                    InetSocketAddress inetSocketAddress = null;
3950    
3951                    if (secure) {
3952                            inetSocketAddress = _securePortalServerInetSocketAddress.get();
3953                    }
3954                    else {
3955                            inetSocketAddress = _portalServerInetSocketAddress.get();
3956                    }
3957    
3958                    if (inetSocketAddress == null) {
3959                            return -1;
3960                    }
3961    
3962                    return inetSocketAddress.getPort();
3963            }
3964    
3965            @Override
3966            public String getPortalURL(HttpServletRequest request) {
3967                    return getPortalURL(request, isSecure(request));
3968            }
3969    
3970            @Override
3971            public String getPortalURL(HttpServletRequest request, boolean secure) {
3972                    return getPortalURL(
3973                            request.getServerName(), request.getServerPort(), secure);
3974            }
3975    
3976            @Override
3977            public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3978                    throws PortalException {
3979    
3980                    String serverName = themeDisplay.getServerName();
3981    
3982                    if (layout == null) {
3983                            layout = themeDisplay.getLayout();
3984                    }
3985    
3986                    if (layout != null) {
3987                            Layout virtualHostLayout = layout;
3988    
3989                            long refererPlid = themeDisplay.getRefererPlid();
3990    
3991                            if (refererPlid > 0) {
3992                                    virtualHostLayout = LayoutLocalServiceUtil.getLayout(
3993                                            refererPlid);
3994                            }
3995    
3996                            LayoutSet virtualHostLayoutSet = virtualHostLayout.getLayoutSet();
3997    
3998                            String virtualHostname = virtualHostLayoutSet.getVirtualHostname();
3999    
4000                            String domain = HttpUtil.getDomain(themeDisplay.getURLPortal());
4001    
4002                            if (Validator.isNotNull(virtualHostname) &&
4003                                    domain.startsWith(virtualHostname)) {
4004    
4005                                    serverName = virtualHostname;
4006                            }
4007                    }
4008    
4009                    return getPortalURL(
4010                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
4011            }
4012    
4013            @Override
4014            public String getPortalURL(PortletRequest portletRequest) {
4015                    return getPortalURL(portletRequest, portletRequest.isSecure());
4016            }
4017    
4018            @Override
4019            public String getPortalURL(PortletRequest portletRequest, boolean secure) {
4020                    return getPortalURL(
4021                            portletRequest.getServerName(), portletRequest.getServerPort(),
4022                            secure);
4023            }
4024    
4025            @Override
4026            public String getPortalURL(
4027                    String serverName, int serverPort, boolean secure) {
4028    
4029                    StringBundler sb = new StringBundler(4);
4030    
4031                    boolean https =
4032                            (secure ||
4033                             StringUtil.equalsIgnoreCase(
4034                                    Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL));
4035    
4036                    if (https) {
4037                            sb.append(Http.HTTPS_WITH_SLASH);
4038                    }
4039                    else {
4040                            sb.append(Http.HTTP_WITH_SLASH);
4041                    }
4042    
4043                    if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
4044                            sb.append(serverName);
4045                    }
4046                    else {
4047                            sb.append(PropsValues.WEB_SERVER_HOST);
4048                    }
4049    
4050                    if (!https) {
4051                            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
4052                                    if ((serverPort != Http.HTTP_PORT) &&
4053                                            (serverPort != Http.HTTPS_PORT)) {
4054    
4055                                            sb.append(StringPool.COLON);
4056                                            sb.append(serverPort);
4057                                    }
4058                            }
4059                            else {
4060                                    if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
4061                                            sb.append(StringPool.COLON);
4062                                            sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
4063                                    }
4064                            }
4065                    }
4066                    else {
4067                            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
4068                                    if ((serverPort != Http.HTTP_PORT) &&
4069                                            (serverPort != Http.HTTPS_PORT)) {
4070    
4071                                            sb.append(StringPool.COLON);
4072                                            sb.append(serverPort);
4073                                    }
4074                            }
4075                            else {
4076                                    if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
4077                                            sb.append(StringPool.COLON);
4078                                            sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
4079                                    }
4080                            }
4081                    }
4082    
4083                    return sb.toString();
4084            }
4085    
4086            @Override
4087            public String getPortalURL(ThemeDisplay themeDisplay)
4088                    throws PortalException {
4089    
4090                    return getPortalURL(null, themeDisplay);
4091            }
4092    
4093            @Override
4094            public String getPortalWebDir() {
4095                    return PropsValues.LIFERAY_WEB_PORTAL_DIR;
4096            }
4097    
4098            /**
4099             * @deprecated As of 6.2.0, replaced by {@link
4100             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelist}
4101             */
4102            @Deprecated
4103            @Override
4104            public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
4105                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
4106            }
4107    
4108            /**
4109             * @deprecated As of 6.2.0, replaced by {@link
4110             *             AuthTokenWhitelistUtil#getPortletInvocationWhitelistActions}
4111             */
4112            @Deprecated
4113            @Override
4114            public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
4115                    return AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
4116            }
4117    
4118            /**
4119             * @deprecated As of 6.1.0, replaced by {@link
4120             *             #getPortletBreadcrumbs(HttpServletRequest)}
4121             */
4122            @Deprecated
4123            @Override
4124            public List<BreadcrumbEntry> getPortletBreadcrumbList(
4125                    HttpServletRequest request) {
4126    
4127                    return getPortletBreadcrumbs(request);
4128            }
4129    
4130            /**
4131             * @deprecated As of 7.0.0, replaced by {@link
4132             *             BreadcrumbUtil#getPortletBreadcrumbEntries(
4133             *             HttpServletRequest)}
4134             */
4135            @Deprecated
4136            @Override
4137            public List<BreadcrumbEntry> getPortletBreadcrumbs(
4138                    HttpServletRequest request) {
4139    
4140                    return BreadcrumbUtil.getPortletBreadcrumbEntries(request);
4141            }
4142    
4143            @Override
4144            public PortletConfig getPortletConfig(
4145                            long companyId, String portletId, ServletContext servletContext)
4146                    throws PortletException {
4147    
4148                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
4149                            companyId, portletId);
4150    
4151                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
4152                            portlet, servletContext);
4153    
4154                    return invokerPortlet.getPortletConfig();
4155            }
4156    
4157            @Override
4158            public String getPortletDescription(
4159                    Portlet portlet, ServletContext servletContext, Locale locale) {
4160    
4161                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4162                            portlet, servletContext);
4163    
4164                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4165    
4166                    String portletDescription = ResourceBundleUtil.getString(
4167                            resourceBundle,
4168                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4169                                    StringPool.PERIOD).concat(portlet.getRootPortletId()));
4170    
4171                    if (Validator.isNull(portletDescription)) {
4172                            portletDescription = ResourceBundleUtil.getString(
4173                                    resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
4174                    }
4175    
4176                    return portletDescription;
4177            }
4178    
4179            @Override
4180            public String getPortletDescription(Portlet portlet, User user) {
4181                    return getPortletDescription(portlet.getPortletId(), user);
4182            }
4183    
4184            @Override
4185            public String getPortletDescription(String portletId, Locale locale) {
4186                    return LanguageUtil.get(
4187                            locale,
4188                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4189                                    StringPool.PERIOD).concat(portletId));
4190            }
4191    
4192            @Override
4193            public String getPortletDescription(String portletId, String languageId) {
4194                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4195    
4196                    return getPortletDescription(portletId, locale);
4197            }
4198    
4199            @Override
4200            public String getPortletDescription(String portletId, User user) {
4201                    return LanguageUtil.get(
4202                            user.getLocale(),
4203                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4204                                    StringPool.PERIOD).concat(portletId));
4205            }
4206    
4207            public LayoutQueryStringComposite
4208                            getPortletFriendlyURLMapperLayoutQueryStringComposite(
4209                                    long groupId, boolean privateLayout, String url,
4210                                    Map<String, String[]> params,
4211                                    Map<String, Object> requestContext)
4212                    throws PortalException {
4213    
4214                    boolean foundFriendlyURLMapper = false;
4215    
4216                    String friendlyURL = url;
4217                    String queryString = StringPool.BLANK;
4218    
4219                    List<Portlet> portlets =
4220                            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
4221    
4222                    for (Portlet portlet : portlets) {
4223                            FriendlyURLMapper friendlyURLMapper =
4224                                    portlet.getFriendlyURLMapperInstance();
4225    
4226                            if (url.endsWith(
4227                                            StringPool.SLASH + friendlyURLMapper.getMapping())) {
4228    
4229                                    url += StringPool.SLASH;
4230                            }
4231    
4232                            int pos = -1;
4233    
4234                            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4235                                    pos = url.indexOf(
4236                                            FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
4237                                                    StringPool.SLASH);
4238                            }
4239                            else {
4240                                    pos = url.indexOf(
4241                                            StringPool.SLASH + friendlyURLMapper.getMapping() +
4242                                                    StringPool.SLASH);
4243                            }
4244    
4245                            if (pos != -1) {
4246                                    foundFriendlyURLMapper = true;
4247    
4248                                    friendlyURL = url.substring(0, pos);
4249    
4250                                    InheritableMap<String, String[]> actualParams =
4251                                            new InheritableMap<>();
4252    
4253                                    if (params != null) {
4254                                            actualParams.setParentMap(params);
4255                                    }
4256    
4257                                    Map<String, String> prpIdentifiers = new HashMap<>();
4258    
4259                                    Set<PublicRenderParameter> publicRenderParameters =
4260                                            portlet.getPublicRenderParameters();
4261    
4262                                    for (PublicRenderParameter publicRenderParameter :
4263                                                    publicRenderParameters) {
4264    
4265                                            QName qName = publicRenderParameter.getQName();
4266    
4267                                            String publicRenderParameterIdentifier =
4268                                                    qName.getLocalPart();
4269                                            String publicRenderParameterName =
4270                                                    PortletQNameUtil.getPublicRenderParameterName(qName);
4271    
4272                                            prpIdentifiers.put(
4273                                                    publicRenderParameterIdentifier,
4274                                                    publicRenderParameterName);
4275                                    }
4276    
4277                                    FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
4278    
4279                                    if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4280                                            friendlyURLMapper.populateParams(
4281                                                    url.substring(pos + 2), actualParams, requestContext);
4282                                    }
4283                                    else {
4284                                            friendlyURLMapper.populateParams(
4285                                                    url.substring(pos), actualParams, requestContext);
4286                                    }
4287    
4288                                    queryString =
4289                                            StringPool.AMPERSAND +
4290                                                    HttpUtil.parameterMapToString(actualParams, false);
4291    
4292                                    break;
4293                            }
4294                    }
4295    
4296                    if (!foundFriendlyURLMapper) {
4297                            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
4298    
4299                            if (x != -1) {
4300                                    int y = url.indexOf(CharPool.SLASH, x + 3);
4301    
4302                                    if (y == -1) {
4303                                            y = url.length();
4304                                    }
4305    
4306                                    String ppid = url.substring(x + 3, y);
4307    
4308                                    if (Validator.isNotNull(ppid)) {
4309                                            friendlyURL = url.substring(0, x);
4310    
4311                                            Map<String, String[]> actualParams = null;
4312    
4313                                            if (params != null) {
4314                                                    actualParams = new HashMap<>(params);
4315                                            }
4316                                            else {
4317                                                    actualParams = new HashMap<>();
4318                                            }
4319    
4320                                            actualParams.put("p_p_id", new String[] {ppid});
4321                                            actualParams.put("p_p_lifecycle", new String[] {"0"});
4322                                            actualParams.put(
4323                                                    "p_p_state",
4324                                                    new String[] {WindowState.MAXIMIZED.toString()});
4325                                            actualParams.put(
4326                                                    "p_p_mode", new String[] {PortletMode.VIEW.toString()});
4327    
4328                                            queryString =
4329                                                    StringPool.AMPERSAND +
4330                                                            HttpUtil.parameterMapToString(actualParams, false);
4331                                    }
4332                            }
4333                    }
4334    
4335                    friendlyURL = StringUtil.replace(
4336                            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
4337    
4338                    if (friendlyURL.endsWith(StringPool.SLASH)) {
4339                            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
4340                    }
4341    
4342                    Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
4343                            groupId, privateLayout, friendlyURL);
4344    
4345                    return new LayoutQueryStringComposite(layout, friendlyURL, queryString);
4346            }
4347    
4348            @Override
4349            public String getPortletId(HttpServletRequest request) {
4350                    LiferayPortletConfig liferayPortletConfig =
4351                            (LiferayPortletConfig)request.getAttribute(
4352                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4353    
4354                    if (liferayPortletConfig != null) {
4355                            return liferayPortletConfig.getPortletId();
4356                    }
4357                    else {
4358                            return null;
4359                    }
4360            }
4361    
4362            @Override
4363            public String getPortletId(PortletRequest portletRequest) {
4364                    LiferayPortletConfig liferayPortletConfig =
4365                            (LiferayPortletConfig)portletRequest.getAttribute(
4366                                    JavaConstants.JAVAX_PORTLET_CONFIG);
4367    
4368                    if (liferayPortletConfig != null) {
4369                            return liferayPortletConfig.getPortletId();
4370                    }
4371                    else {
4372                            return null;
4373                    }
4374            }
4375    
4376            @Override
4377            public String getPortletLongTitle(Portlet portlet, Locale locale) {
4378                    return getPortletLongTitle(portlet.getPortletId(), locale);
4379            }
4380    
4381            @Override
4382            public String getPortletLongTitle(
4383                    Portlet portlet, ServletContext servletContext, Locale locale) {
4384    
4385                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4386                            portlet, servletContext);
4387    
4388                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4389    
4390                    try {
4391                            String portletLongTitle = ResourceBundleUtil.getString(
4392                                    resourceBundle, JavaConstants.JAVAX_PORTLET_LONG_TITLE);
4393    
4394                            if (portletLongTitle.startsWith(
4395                                            JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
4396    
4397                                    portletLongTitle = getPortletTitle(
4398                                            portlet, servletContext, locale);
4399                            }
4400    
4401                            return portletLongTitle;
4402                    }
4403                    catch (Exception e) {
4404                            return getPortletTitle(portlet, servletContext, locale);
4405                    }
4406            }
4407    
4408            @Override
4409            public String getPortletLongTitle(Portlet portlet, String languageId) {
4410                    return getPortletLongTitle(portlet.getPortletId(), languageId);
4411            }
4412    
4413            @Override
4414            public String getPortletLongTitle(Portlet portlet, User user) {
4415                    return getPortletLongTitle(portlet.getPortletId(), user);
4416            }
4417    
4418            @Override
4419            public String getPortletLongTitle(String portletId, Locale locale) {
4420                    String portletLongTitle = LanguageUtil.get(
4421                            locale,
4422                            JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
4423                                    StringPool.PERIOD).concat(portletId),
4424                            StringPool.BLANK);
4425    
4426                    if (Validator.isNull(portletLongTitle)) {
4427                            portletLongTitle = getPortletTitle(portletId, locale);
4428                    }
4429    
4430                    return portletLongTitle;
4431            }
4432    
4433            @Override
4434            public String getPortletLongTitle(String portletId, String languageId) {
4435                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4436    
4437                    return getPortletLongTitle(portletId, locale);
4438            }
4439    
4440            @Override
4441            public String getPortletLongTitle(String portletId, User user) {
4442                    return getPortletLongTitle(portletId, user.getLocale());
4443            }
4444    
4445            @Override
4446            public String getPortletNamespace(String portletId) {
4447                    return StringPool.UNDERLINE.concat(portletId).concat(
4448                            StringPool.UNDERLINE);
4449            }
4450    
4451            @Override
4452            public String getPortletTitle(Portlet portlet, Locale locale) {
4453                    return getPortletTitle(portlet.getPortletId(), locale);
4454            }
4455    
4456            @Override
4457            public String getPortletTitle(
4458                    Portlet portlet, ServletContext servletContext, Locale locale) {
4459    
4460                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4461                            portlet, servletContext);
4462    
4463                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4464    
4465                    String portletTitle = ResourceBundleUtil.getString(
4466                            resourceBundle,
4467                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4468                                    portlet.getRootPortletId()));
4469    
4470                    if (Validator.isNull(portletTitle)) {
4471                            portletTitle = ResourceBundleUtil.getString(
4472                                    resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4473                    }
4474    
4475                    return portletTitle;
4476            }
4477    
4478            @Override
4479            public String getPortletTitle(Portlet portlet, String languageId) {
4480                    return getPortletTitle(portlet.getPortletId(), languageId);
4481            }
4482    
4483            @Override
4484            public String getPortletTitle(Portlet portlet, User user) {
4485                    return getPortletTitle(portlet.getPortletId(), user);
4486            }
4487    
4488            @Override
4489            public String getPortletTitle(PortletRequest portletRequest) {
4490                    long companyId = getCompanyId(portletRequest);
4491                    String portletId = (String)portletRequest.getAttribute(
4492                            WebKeys.PORTLET_ID);
4493    
4494                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
4495                            companyId, portletId);
4496    
4497                    HttpServletRequest request = getHttpServletRequest(portletRequest);
4498    
4499                    ServletContext servletContext = (ServletContext)request.getAttribute(
4500                            WebKeys.CTX);
4501    
4502                    Locale locale = portletRequest.getLocale();
4503    
4504                    return getPortletTitle(portlet, servletContext, locale);
4505            }
4506    
4507            @Override
4508            public String getPortletTitle(PortletResponse portletResponse) {
4509                    PortletResponseImpl portletResponseImpl =
4510                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
4511    
4512                    return ((RenderResponseImpl)portletResponseImpl).getTitle();
4513            }
4514    
4515            @Override
4516            public String getPortletTitle(String portletId, Locale locale) {
4517                    PortletConfig portletConfig = PortletConfigFactoryUtil.get(portletId);
4518    
4519                    return getPortletTitle(
4520                            portletId, portletConfig.getResourceBundle(locale));
4521            }
4522    
4523            @Override
4524            public String getPortletTitle(
4525                    String portletId, ResourceBundle resourceBundle) {
4526    
4527                    portletId = PortletConstants.getRootPortletId(portletId);
4528    
4529                    String portletTitle = LanguageUtil.get(
4530                            resourceBundle,
4531                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4532                                    portletId),
4533                            null);
4534    
4535                    if (Validator.isNull(portletTitle)) {
4536                            portletTitle = ResourceBundleUtil.getString(
4537                                    resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4538                    }
4539    
4540                    return portletTitle;
4541            }
4542    
4543            @Override
4544            public String getPortletTitle(String portletId, String languageId) {
4545                    Locale locale = LocaleUtil.fromLanguageId(languageId);
4546    
4547                    return getPortletTitle(portletId, locale);
4548            }
4549    
4550            @Override
4551            public String getPortletTitle(String portletId, User user) {
4552                    return LanguageUtil.get(
4553                            user.getLocale(),
4554                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4555                                    portletId));
4556            }
4557    
4558            @Override
4559            public String getPortletXmlFileName() {
4560                    if (PrefsPropsUtil.getBoolean(
4561                                    PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
4562                                    PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
4563    
4564                            return PORTLET_XML_FILE_NAME_CUSTOM;
4565                    }
4566                    else {
4567                            return PORTLET_XML_FILE_NAME_STANDARD;
4568                    }
4569            }
4570    
4571            @Override
4572            public PortletPreferences getPreferences(HttpServletRequest request) {
4573                    RenderRequest renderRequest = (RenderRequest)request.getAttribute(
4574                            JavaConstants.JAVAX_PORTLET_REQUEST);
4575    
4576                    PortletPreferences portletPreferences = null;
4577    
4578                    if (renderRequest != null) {
4579                            PortletPreferencesWrapper portletPreferencesWrapper =
4580                                    (PortletPreferencesWrapper)renderRequest.getPreferences();
4581    
4582                            portletPreferences =
4583                                    portletPreferencesWrapper.getPortletPreferencesImpl();
4584                    }
4585    
4586                    return portletPreferences;
4587            }
4588    
4589            @Override
4590            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
4591                    PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
4592    
4593                    if (portletBag == null) {
4594                            return null;
4595                    }
4596    
4597                    List<PreferencesValidator> preferencesValidatorInstances =
4598                            portletBag.getPreferencesValidatorInstances();
4599    
4600                    if (preferencesValidatorInstances.isEmpty()) {
4601                            return null;
4602                    }
4603    
4604                    return preferencesValidatorInstances.get(0);
4605            }
4606    
4607            @Override
4608            public String getRelativeHomeURL(HttpServletRequest request)
4609                    throws PortalException {
4610    
4611                    Company company = getCompany(request);
4612    
4613                    String homeURL = company.getHomeURL();
4614    
4615                    if (Validator.isNull(homeURL)) {
4616                            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
4617                    }
4618    
4619                    return homeURL;
4620            }
4621    
4622            @Override
4623            public ResourceBundle getResourceBundle(Locale locale) {
4624                    return LanguageResources.getResourceBundle(locale);
4625            }
4626    
4627            @Override
4628            public long getScopeGroupId(HttpServletRequest request)
4629                    throws PortalException {
4630    
4631                    String portletId = getPortletId(request);
4632    
4633                    return getScopeGroupId(request, portletId);
4634            }
4635    
4636            @Override
4637            public long getScopeGroupId(HttpServletRequest request, String portletId)
4638                    throws PortalException {
4639    
4640                    return getScopeGroupId(request, portletId, false);
4641            }
4642    
4643            @Override
4644            public long getScopeGroupId(
4645                            HttpServletRequest request, String portletId,
4646                            boolean checkStagingGroup)
4647                    throws PortalException {
4648    
4649                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4650    
4651                    long scopeGroupId = 0;
4652    
4653                    if (layout != null) {
4654                            Group group = layout.getGroup();
4655    
4656                            long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
4657    
4658                            if (doAsGroupId <= 0) {
4659                                    HttpServletRequest originalRequest = getOriginalServletRequest(
4660                                            request);
4661    
4662                                    doAsGroupId = ParamUtil.getLong(originalRequest, "doAsGroupId");
4663                            }
4664    
4665                            Group doAsGroup = null;
4666    
4667                            if (doAsGroupId > 0) {
4668                                    doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
4669                            }
4670    
4671                            if (group.isControlPanel()) {
4672                                    if (doAsGroupId > 0) {
4673                                            scopeGroupId = doAsGroupId;
4674                                    }
4675    
4676                                    group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
4677    
4678                                    if ((group != null) && group.hasStagingGroup()) {
4679                                            try {
4680                                                    Group stagingGroup = group.getStagingGroup();
4681    
4682                                                    scopeGroupId = stagingGroup.getGroupId();
4683                                            }
4684                                            catch (Exception e) {
4685                                            }
4686                                    }
4687                            }
4688                            else if (doAsGroup != null) {
4689                                    scopeGroupId = doAsGroupId;
4690                            }
4691    
4692                            if ((group != null) && group.isInheritContent()) {
4693                                    Group layoutGroup = layout.getGroup();
4694    
4695                                    if (!layoutGroup.isControlPanel()) {
4696                                            scopeGroupId = group.getParentGroupId();
4697                                    }
4698                            }
4699    
4700                            if ((portletId != null) && (group != null) &&
4701                                    (group.isStaged() || group.isStagingGroup())) {
4702    
4703                                    Group liveGroup = group;
4704    
4705                                    if (group.isStagingGroup()) {
4706                                            liveGroup = group.getLiveGroup();
4707                                    }
4708    
4709                                    if (liveGroup.isStaged() &&
4710                                            !liveGroup.isStagedPortlet(portletId)) {
4711    
4712                                            Layout liveGroupLayout =
4713                                                    LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
4714                                                            layout.getUuid(), liveGroup.getGroupId(),
4715                                                            layout.isPrivateLayout());
4716    
4717                                            if ((liveGroupLayout != null) &&
4718                                                    liveGroupLayout.hasScopeGroup()) {
4719    
4720                                                    scopeGroupId = getScopeGroupId(
4721                                                            liveGroupLayout, portletId);
4722                                            }
4723                                            else if (checkStagingGroup &&
4724                                                             !liveGroup.isStagedRemotely()) {
4725    
4726                                                    Group stagingGroup = liveGroup.getStagingGroup();
4727    
4728                                                    scopeGroupId = stagingGroup.getGroupId();
4729                                            }
4730                                            else {
4731                                                    scopeGroupId = liveGroup.getGroupId();
4732                                            }
4733                                    }
4734                            }
4735                    }
4736    
4737                    if (scopeGroupId <= 0) {
4738                            scopeGroupId = getScopeGroupId(layout, portletId);
4739                    }
4740    
4741                    return scopeGroupId;
4742            }
4743    
4744            @Override
4745            public long getScopeGroupId(Layout layout) {
4746                    if (layout == null) {
4747                            return 0;
4748                    }
4749                    else {
4750                            return layout.getGroupId();
4751                    }
4752            }
4753    
4754            @Override
4755            public long getScopeGroupId(Layout layout, String portletId) {
4756                    if (layout == null) {
4757                            return 0;
4758                    }
4759    
4760                    if (Validator.isNull(portletId)) {
4761                            return layout.getGroupId();
4762                    }
4763    
4764                    try {
4765                            PortletPreferences portletSetup =
4766                                    PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
4767                                            layout, portletId);
4768    
4769                            String scopeType = GetterUtil.getString(
4770                                    portletSetup.getValue("lfrScopeType", null));
4771    
4772                            if (Validator.isNull(scopeType)) {
4773                                    return layout.getGroupId();
4774                            }
4775    
4776                            if (scopeType.equals("company")) {
4777                                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4778                                            layout.getCompanyId());
4779    
4780                                    return companyGroup.getGroupId();
4781                            }
4782    
4783                            String scopeLayoutUuid = GetterUtil.getString(
4784                                    portletSetup.getValue("lfrScopeLayoutUuid", null));
4785    
4786                            Layout scopeLayout =
4787                                    LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
4788                                            scopeLayoutUuid, layout.getGroupId(),
4789                                            layout.isPrivateLayout());
4790    
4791                            Group scopeGroup = scopeLayout.getScopeGroup();
4792    
4793                            return scopeGroup.getGroupId();
4794                    }
4795                    catch (Exception e) {
4796                            return layout.getGroupId();
4797                    }
4798            }
4799    
4800            @Override
4801            public long getScopeGroupId(long plid) {
4802                    Layout layout = null;
4803    
4804                    try {
4805                            layout = LayoutLocalServiceUtil.getLayout(plid);
4806                    }
4807                    catch (Exception e) {
4808                    }
4809    
4810                    return getScopeGroupId(layout);
4811            }
4812    
4813            @Override
4814            public long getScopeGroupId(PortletRequest portletRequest)
4815                    throws PortalException {
4816    
4817                    return getScopeGroupId(getHttpServletRequest(portletRequest));
4818            }
4819    
4820            @Override
4821            public User getSelectedUser(HttpServletRequest request)
4822                    throws PortalException {
4823    
4824                    return getSelectedUser(request, true);
4825            }
4826    
4827            @Override
4828            public User getSelectedUser(
4829                            HttpServletRequest request, boolean checkPermission)
4830                    throws PortalException {
4831    
4832                    long userId = ParamUtil.getLong(request, "p_u_i_d");
4833    
4834                    User user = null;
4835    
4836                    try {
4837                            if (checkPermission) {
4838                                    user = UserServiceUtil.getUserById(userId);
4839                            }
4840                            else {
4841                                    user = UserLocalServiceUtil.getUserById(userId);
4842                            }
4843                    }
4844                    catch (NoSuchUserException nsue) {
4845                    }
4846    
4847                    return user;
4848            }
4849    
4850            @Override
4851            public User getSelectedUser(PortletRequest portletRequest)
4852                    throws PortalException {
4853    
4854                    return getSelectedUser(portletRequest, true);
4855            }
4856    
4857            @Override
4858            public User getSelectedUser(
4859                            PortletRequest portletRequest, boolean checkPermission)
4860                    throws PortalException {
4861    
4862                    return getSelectedUser(
4863                            getHttpServletRequest(portletRequest), checkPermission);
4864            }
4865    
4866            @Override
4867            public String getServletContextName() {
4868                    return _servletContextName;
4869            }
4870    
4871            @Override
4872            public long[] getSharedContentSiteGroupIds(
4873                            long companyId, long groupId, long userId)
4874                    throws PortalException {
4875    
4876                    Set<Group> groups = new LinkedHashSet<>();
4877    
4878                    Group siteGroup = doGetCurrentSiteGroup(groupId);
4879    
4880                    if (siteGroup != null) {
4881    
4882                            // Current site
4883    
4884                            groups.add(siteGroup);
4885    
4886                            // Descendant sites
4887    
4888                            groups.addAll(siteGroup.getDescendants(true));
4889    
4890                            // Layout scopes
4891    
4892                            groups.addAll(
4893                                    GroupLocalServiceUtil.getGroups(
4894                                            siteGroup.getCompanyId(), Layout.class.getName(),
4895                                            siteGroup.getGroupId()));
4896                    }
4897    
4898                    // Administered sites
4899    
4900                    if (PrefsPropsUtil.getBoolean(
4901                                    companyId,
4902                                    PropsKeys.
4903                                            SITES_CONTENT_SHARING_THROUGH_ADMINISTRATORS_ENABLED)) {
4904    
4905                            LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
4906    
4907                            groupParams.put("site", Boolean.TRUE);
4908                            groupParams.put("usersGroups", userId);
4909    
4910                            groups.addAll(
4911                                    GroupLocalServiceUtil.search(
4912                                            companyId, null, null, groupParams, QueryUtil.ALL_POS,
4913                                            QueryUtil.ALL_POS, null));
4914                    }
4915    
4916                    // Ancestor sites and global site
4917    
4918                    int sitesContentSharingWithChildrenEnabled = PrefsPropsUtil.getInteger(
4919                            companyId, PropsKeys.SITES_CONTENT_SHARING_WITH_CHILDREN_ENABLED);
4920    
4921                    if (sitesContentSharingWithChildrenEnabled !=
4922                                    Sites.CONTENT_SHARING_WITH_CHILDREN_DISABLED) {
4923    
4924                            groups.addAll(doGetAncestorSiteGroups(groupId, true));
4925                    }
4926    
4927                    long[] groupIds = new long[groups.size()];
4928    
4929                    int i = 0;
4930    
4931                    for (Group group : groups) {
4932                            groupIds[i++] = group.getGroupId();
4933                    }
4934    
4935                    return groupIds;
4936            }
4937    
4938            /**
4939             * @deprecated As of 7.0.0, replaced by {@link
4940             *             #getControlPanelPortletURL(PortletRequest, Group, String,
4941             *             String)}
4942             */
4943            @Deprecated
4944            @Override
4945            public PortletURL getSiteAdministrationURL(
4946                    HttpServletRequest request, ThemeDisplay themeDisplay,
4947                    String portletId) {
4948    
4949                    PortletURL portletURL = getControlPanelPortletURL(
4950                            request, portletId, PortletRequest.RENDER_PHASE);
4951    
4952                    portletURL.setParameter("redirect", themeDisplay.getURLCurrent());
4953    
4954                    return portletURL;
4955            }
4956    
4957            /**
4958             * @deprecated As of 7.0.0, replaced by {@link
4959             *             #getControlPanelPortletURL(PortletRequest, Group, String,
4960             *             String)}
4961             */
4962            @Deprecated
4963            @Override
4964            public PortletURL getSiteAdministrationURL(
4965                    PortletResponse portletResponse, ThemeDisplay themeDisplay,
4966                    String portletName) {
4967    
4968                    LiferayPortletResponse liferayPortletResponse =
4969                            (LiferayPortletResponse)portletResponse;
4970    
4971                    LiferayPortletURL siteAdministrationURL =
4972                            liferayPortletResponse.createRenderURL(portletName);
4973    
4974                    siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4975                    siteAdministrationURL.setParameter(
4976                            "redirect", themeDisplay.getURLCurrent());
4977    
4978                    return siteAdministrationURL;
4979            }
4980    
4981            /**
4982             * @deprecated As of 7.0.0, replaced by {@link
4983             *             #getCurrentAndAncestorSiteGroupIds(long)}
4984             */
4985            @Deprecated
4986            @Override
4987            public long[] getSiteAndCompanyGroupIds(long groupId)
4988                    throws PortalException {
4989    
4990                    Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
4991    
4992                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4993                            scopeGroup.getCompanyId());
4994    
4995                    if (scopeGroup.isLayout()) {
4996                            return new long[] {
4997                                    groupId, scopeGroup.getParentGroupId(),
4998                                    companyGroup.getGroupId()
4999                            };
5000                    }
5001                    else if (scopeGroup.isLayoutSetPrototype() ||
5002                                     scopeGroup.isOrganization() || scopeGroup.isRegularSite() ||
5003                                     scopeGroup.isUser()) {
5004    
5005                            return new long[] {groupId, companyGroup.getGroupId()};
5006                    }
5007                    else {
5008                            return new long[] {companyGroup.getGroupId()};
5009                    }
5010            }
5011    
5012            /**
5013             * @deprecated As of 7.0.0, replaced by {@link
5014             *             #getCurrentAndAncestorSiteGroupIds(long)}
5015             */
5016            @Deprecated
5017            @Override
5018            public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
5019                    throws PortalException {
5020    
5021                    return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
5022            }
5023    
5024            @Override
5025            public Locale getSiteDefaultLocale(long groupId) throws PortalException {
5026                    if (groupId <= 0) {
5027                            return LocaleUtil.getDefault();
5028                    }
5029    
5030                    Group group = GroupLocalServiceUtil.getGroup(groupId);
5031    
5032                    Group liveGroup = group;
5033    
5034                    if (group.isStagingGroup()) {
5035                            liveGroup = group.getLiveGroup();
5036                    }
5037    
5038                    if (LanguageUtil.isInheritLocales(liveGroup.getGroupId())) {
5039                            return LocaleUtil.getDefault();
5040                    }
5041    
5042                    UnicodeProperties typeSettingsProperties =
5043                            liveGroup.getTypeSettingsProperties();
5044    
5045                    User defaultUser = UserLocalServiceUtil.getDefaultUser(
5046                            group.getCompanyId());
5047    
5048                    String languageId = GetterUtil.getString(
5049                            typeSettingsProperties.getProperty("languageId"),
5050                            defaultUser.getLanguageId());
5051    
5052                    return LocaleUtil.fromLanguageId(languageId);
5053            }
5054    
5055            @Override
5056            public long getSiteGroupId(long groupId) {
5057                    if (groupId <= 0) {
5058                            return 0;
5059                    }
5060    
5061                    Group group = GroupLocalServiceUtil.fetchGroup(groupId);
5062    
5063                    if (group == null) {
5064                            return 0;
5065                    }
5066    
5067                    long siteGroupId = groupId;
5068    
5069                    if (group.isLayout()) {
5070                            siteGroupId = group.getParentGroupId();
5071                    }
5072    
5073                    return siteGroupId;
5074            }
5075    
5076            @Override
5077            public String getSiteLoginURL(ThemeDisplay themeDisplay)
5078                    throws PortalException {
5079    
5080                    if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
5081                            return null;
5082                    }
5083    
5084                    List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
5085    
5086                    if (layouts == null) {
5087                            return null;
5088                    }
5089    
5090                    for (Layout layout : layouts) {
5091                            String friendlyURL = layout.getFriendlyURL(
5092                                    themeDisplay.getLocale());
5093    
5094                            if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
5095                                    if (themeDisplay.getLayout() == null) {
5096                                            break;
5097                                    }
5098    
5099                                    String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
5100                                            layout.getLayoutSet(), themeDisplay);
5101    
5102                                    return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
5103                            }
5104                    }
5105    
5106                    return null;
5107            }
5108    
5109            @Override
5110            public String getStaticResourceURL(HttpServletRequest request, String uri) {
5111                    return getStaticResourceURL(request, uri, null, 0);
5112            }
5113    
5114            @Override
5115            public String getStaticResourceURL(
5116                    HttpServletRequest request, String uri, long timestamp) {
5117    
5118                    return getStaticResourceURL(request, uri, null, timestamp);
5119            }
5120    
5121            @Override
5122            public String getStaticResourceURL(
5123                    HttpServletRequest request, String uri, String queryString) {
5124    
5125                    return getStaticResourceURL(request, uri, queryString, 0);
5126            }
5127    
5128            @Override
5129            public String getStaticResourceURL(
5130                    HttpServletRequest request, String uri, String queryString,
5131                    long timestamp) {
5132    
5133                    if (uri.indexOf(CharPool.QUESTION) != -1) {
5134                            return uri;
5135                    }
5136    
5137                    if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
5138                            uri = uri.substring(1);
5139                    }
5140    
5141                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5142                            WebKeys.THEME_DISPLAY);
5143    
5144                    Theme theme = themeDisplay.getTheme();
5145                    ColorScheme colorScheme = themeDisplay.getColorScheme();
5146    
5147                    Map<String, String[]> parameterMap = null;
5148    
5149                    if (Validator.isNotNull(queryString)) {
5150                            parameterMap = HttpUtil.getParameterMap(queryString);
5151                    }
5152    
5153                    StringBundler sb = new StringBundler(18);
5154    
5155                    // URI
5156    
5157                    sb.append(uri);
5158                    sb.append(StringPool.QUESTION);
5159    
5160                    // Browser id
5161    
5162                    if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
5163                            sb.append("&browserId=");
5164                            sb.append(BrowserSnifferUtil.getBrowserId(request));
5165                    }
5166    
5167                    // Theme and color scheme
5168    
5169                    if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
5170                            ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
5171    
5172                            sb.append("&themeId=");
5173                            sb.append(HttpUtil.encodeURL(theme.getThemeId()));
5174                    }
5175    
5176                    if (uri.endsWith(".jsp") &&
5177                            ((parameterMap == null) ||
5178                             !parameterMap.containsKey("colorSchemeId"))) {
5179    
5180                            sb.append("&colorSchemeId=");
5181                            sb.append(HttpUtil.encodeURL(colorScheme.getColorSchemeId()));
5182                    }
5183    
5184                    // Minifier
5185    
5186                    if ((parameterMap == null) ||
5187                            !parameterMap.containsKey("minifierType")) {
5188    
5189                            String minifierType = StringPool.BLANK;
5190    
5191                            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
5192                                    (uri.endsWith(".jsp") && uri.contains("/css/"))) {
5193    
5194                                    if (themeDisplay.isThemeCssFastLoad()) {
5195                                            minifierType = "css";
5196                                    }
5197                            }
5198                            else if (themeDisplay.isThemeJsFastLoad()) {
5199                                    minifierType = "js";
5200                            }
5201    
5202                            if (Validator.isNotNull(minifierType)) {
5203                                    sb.append("&minifierType=");
5204                                    sb.append(minifierType);
5205                            }
5206                    }
5207    
5208                    // Query string
5209    
5210                    if (Validator.isNotNull(queryString)) {
5211                            if (!queryString.startsWith(StringPool.AMPERSAND)) {
5212                                    sb.append(StringPool.AMPERSAND);
5213                            }
5214    
5215                            sb.append(queryString);
5216                    }
5217    
5218                    // Language id
5219    
5220                    sb.append("&languageId=");
5221                    sb.append(themeDisplay.getLanguageId());
5222    
5223                    // Build number
5224    
5225                    sb.append("&b=");
5226                    sb.append(ReleaseInfo.getBuildNumber());
5227    
5228                    // Timestamp
5229    
5230                    if (((parameterMap == null) || !parameterMap.containsKey("t")) &&
5231                             !(timestamp < 0)) {
5232    
5233                            if (timestamp == 0) {
5234                                    String portalURL = getPortalURL(request);
5235    
5236                                    String path = StringUtil.replace(
5237                                            uri, portalURL, StringPool.BLANK);
5238    
5239                                    if (path.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
5240                                            ServletContext servletContext =
5241                                                    (ServletContext)request.getAttribute(WebKeys.CTX);
5242    
5243                                            timestamp = ServletContextUtil.getLastModified(
5244                                                    servletContext, path, true);
5245                                    }
5246                                    else if (PortalWebResourcesUtil.hasContextPath(path)) {
5247                                            timestamp = PortalWebResourcesUtil.getLastModified(
5248                                                    PortalWebResourcesUtil.getPathResourceType(path));
5249                                    }
5250                                    else {
5251                                            timestamp = theme.getTimestamp();
5252                                    }
5253                            }
5254    
5255                            sb.append("&t=");
5256                            sb.append(timestamp);
5257                    }
5258    
5259                    String url = sb.toString();
5260    
5261                    url = StringUtil.replace(url, "?&", StringPool.QUESTION);
5262    
5263                    return url;
5264            }
5265    
5266            @Override
5267            public String getStrutsAction(HttpServletRequest request) {
5268                    String strutsAction = ParamUtil.getString(request, "struts_action");
5269    
5270                    if (Validator.isNotNull(strutsAction)) {
5271    
5272                            // This method should only return a Struts action if you're dealing
5273                            // with a regular HTTP servlet request, not a portlet HTTP servlet
5274                            // request.
5275    
5276                            return StringPool.BLANK;
5277                    }
5278    
5279                    return getPortletParam(request, "struts_action");
5280            }
5281    
5282            @Override
5283            public String[] getSystemGroups() {
5284                    return _allSystemGroups;
5285            }
5286    
5287            @Override
5288            public String[] getSystemOrganizationRoles() {
5289                    return _allSystemOrganizationRoles;
5290            }
5291    
5292            @Override
5293            public String[] getSystemRoles() {
5294                    return _allSystemRoles;
5295            }
5296    
5297            @Override
5298            public String[] getSystemSiteRoles() {
5299                    return _allSystemSiteRoles;
5300            }
5301    
5302            @Override
5303            public String getUniqueElementId(
5304                    HttpServletRequest request, String namespace, String elementId) {
5305    
5306                    String uniqueElementId = elementId;
5307    
5308                    Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
5309                            WebKeys.UNIQUE_ELEMENT_IDS);
5310    
5311                    if (uniqueElementIds == null) {
5312                            uniqueElementIds = new ConcurrentHashSet<>();
5313    
5314                            request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
5315                    }
5316                    else {
5317                            int i = 1;
5318    
5319                            while (uniqueElementIds.contains(
5320                                                    namespace.concat(uniqueElementId))) {
5321    
5322                                    if (Validator.isNull(elementId) ||
5323                                            elementId.endsWith(StringPool.UNDERLINE)) {
5324    
5325                                            uniqueElementId = elementId.concat(String.valueOf(i));
5326                                    }
5327                                    else {
5328                                            uniqueElementId =
5329                                                    elementId.concat(StringPool.UNDERLINE).concat(
5330                                                            String.valueOf(i));
5331                                    }
5332    
5333                                    i++;
5334                            }
5335                    }
5336    
5337                    uniqueElementIds.add(namespace.concat(uniqueElementId));
5338    
5339                    return uniqueElementId;
5340            }
5341    
5342            @Override
5343            public String getUniqueElementId(
5344                    PortletRequest request, String namespace, String elementId) {
5345    
5346                    return getUniqueElementId(
5347                            getHttpServletRequest(request), namespace, elementId);
5348            }
5349    
5350            @Override
5351            public UploadPortletRequest getUploadPortletRequest(
5352                    PortletRequest portletRequest) {
5353    
5354                    PortletRequestImpl portletRequestImpl =
5355                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
5356    
5357                    DynamicServletRequest dynamicRequest =
5358                            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
5359    
5360                    HttpServletRequestWrapper requestWrapper =
5361                            (HttpServletRequestWrapper)dynamicRequest.getRequest();
5362    
5363                    UploadServletRequest uploadServletRequest = getUploadServletRequest(
5364                            requestWrapper);
5365    
5366                    return new UploadPortletRequestImpl(
5367                            uploadServletRequest, portletRequestImpl,
5368                            getPortletNamespace(portletRequestImpl.getPortletName()));
5369            }
5370    
5371            @Override
5372            public UploadServletRequest getUploadServletRequest(
5373                    HttpServletRequest request) {
5374    
5375                    List<PersistentHttpServletRequestWrapper>
5376                            persistentHttpServletRequestWrappers = new ArrayList<>();
5377    
5378                    HttpServletRequest currentRequest = request;
5379    
5380                    while (currentRequest instanceof HttpServletRequestWrapper) {
5381                            if (currentRequest instanceof UploadServletRequest) {
5382                                    return (UploadServletRequest)currentRequest;
5383                            }
5384    
5385                            Class<?> currentRequestClass = currentRequest.getClass();
5386    
5387                            String currentRequestClassName = currentRequestClass.getName();
5388    
5389                            if (!currentRequestClassName.startsWith("com.liferay.")) {
5390                                    break;
5391                            }
5392    
5393                            if (currentRequest instanceof
5394                                            PersistentHttpServletRequestWrapper) {
5395    
5396                                    PersistentHttpServletRequestWrapper
5397                                            persistentHttpServletRequestWrapper =
5398                                                    (PersistentHttpServletRequestWrapper)currentRequest;
5399    
5400                                    persistentHttpServletRequestWrappers.add(
5401                                            persistentHttpServletRequestWrapper.clone());
5402                            }
5403    
5404                            HttpServletRequestWrapper httpServletRequestWrapper =
5405                                    (HttpServletRequestWrapper)currentRequest;
5406    
5407                            currentRequest =
5408                                    (HttpServletRequest)httpServletRequestWrapper.getRequest();
5409                    }
5410    
5411                    if (ServerDetector.isWebLogic()) {
5412                            currentRequest = new NonSerializableObjectRequestWrapper(
5413                                    currentRequest);
5414                    }
5415    
5416                    for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5417                                    i--) {
5418    
5419                            HttpServletRequestWrapper httpServletRequestWrapper =
5420                                    persistentHttpServletRequestWrappers.get(i);
5421    
5422                            httpServletRequestWrapper.setRequest(currentRequest);
5423    
5424                            currentRequest = httpServletRequestWrapper;
5425                    }
5426    
5427                    return new UploadServletRequestImpl(currentRequest);
5428            }
5429    
5430            @Override
5431            public Date getUptime() {
5432                    return _upTime;
5433            }
5434    
5435            @Override
5436            public String getURLWithSessionId(String url, String sessionId) {
5437                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5438                            return url;
5439                    }
5440    
5441                    if (Validator.isNull(url)) {
5442                            return url;
5443                    }
5444    
5445                    // LEP-4787
5446    
5447                    int x = url.indexOf(CharPool.SEMICOLON);
5448    
5449                    if (x != -1) {
5450                            return url;
5451                    }
5452    
5453                    x = url.indexOf(CharPool.QUESTION);
5454    
5455                    if (x != -1) {
5456                            StringBundler sb = new StringBundler(4);
5457    
5458                            sb.append(url.substring(0, x));
5459                            sb.append(JSESSIONID);
5460                            sb.append(sessionId);
5461                            sb.append(url.substring(x));
5462    
5463                            return sb.toString();
5464                    }
5465    
5466                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
5467                    // http://www.abc.com/;jsessionid=XYZ does work.
5468    
5469                    x = url.indexOf(StringPool.DOUBLE_SLASH);
5470    
5471                    StringBundler sb = new StringBundler(4);
5472    
5473                    sb.append(url);
5474    
5475                    if (x != -1) {
5476                            int y = url.lastIndexOf(CharPool.SLASH);
5477    
5478                            if ((x + 1) == y) {
5479                                    sb.append(StringPool.SLASH);
5480                            }
5481                    }
5482    
5483                    sb.append(JSESSIONID);
5484                    sb.append(sessionId);
5485    
5486                    return sb.toString();
5487            }
5488    
5489            @Override
5490            public User getUser(HttpServletRequest request) throws PortalException {
5491                    User user = (User)request.getAttribute(WebKeys.USER);
5492    
5493                    if (user != null) {
5494                            return user;
5495                    }
5496    
5497                    long userId = getUserId(request);
5498    
5499                    if (userId <= 0) {
5500    
5501                            // Portlet WARs may have the correct remote user and not have the
5502                            // correct user id because the user id is saved in the session and
5503                            // may not be accessible by the portlet WAR's session. This behavior
5504                            // is inconsistent across different application servers.
5505    
5506                            String remoteUser = request.getRemoteUser();
5507    
5508                            if ((remoteUser == null) && !PropsValues.PORTAL_JAAS_ENABLE) {
5509                                    HttpSession session = request.getSession();
5510    
5511                                    remoteUser = (String)session.getAttribute("j_remoteuser");
5512                            }
5513    
5514                            if (remoteUser == null) {
5515                                    return null;
5516                            }
5517    
5518                            if (PropsValues.PORTAL_JAAS_ENABLE) {
5519                                    long companyId = getCompanyId(request);
5520    
5521                                    try {
5522                                            userId = JAASHelper.getJaasUserId(companyId, remoteUser);
5523                                    }
5524                                    catch (Exception e) {
5525                                            if (_log.isWarnEnabled()) {
5526                                                    _log.warn(e, e);
5527                                            }
5528                                    }
5529                            }
5530                            else {
5531                                    userId = GetterUtil.getLong(remoteUser);
5532                            }
5533                    }
5534    
5535                    if (userId > 0) {
5536                            user = UserLocalServiceUtil.getUserById(userId);
5537    
5538                            request.setAttribute(WebKeys.USER, user);
5539                    }
5540    
5541                    Cookie[] cookies = request.getCookies();
5542    
5543                    if (cookies != null) {
5544                            for (Cookie cookie : cookies) {
5545                                    String cookieName = cookie.getName();
5546    
5547                                    if (cookieName.startsWith(
5548                                                    CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5549    
5550                                            user.addRemotePreference(
5551                                                    new CookieRemotePreference(cookie));
5552                                    }
5553                            }
5554                    }
5555    
5556                    return user;
5557            }
5558    
5559            @Override
5560            public User getUser(PortletRequest portletRequest) throws PortalException {
5561                    return getUser(getHttpServletRequest(portletRequest));
5562            }
5563    
5564            @Override
5565            public String getUserEmailAddress(long userId) {
5566                    try {
5567                            User user = UserLocalServiceUtil.getUserById(userId);
5568    
5569                            return user.getEmailAddress();
5570                    }
5571                    catch (PortalException pe) {
5572                            return StringPool.BLANK;
5573                    }
5574            }
5575    
5576            @Override
5577            public long getUserId(HttpServletRequest request) {
5578                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5579    
5580                    if (userIdObj != null) {
5581                            return userIdObj.longValue();
5582                    }
5583    
5584                    String actionName = getPortletParam(request, "actionName");
5585                    String mvcRenderCommandName = ParamUtil.getString(
5586                            request, "mvcRenderCommandName");
5587                    String path = GetterUtil.getString(request.getPathInfo());
5588                    String strutsAction = getStrutsAction(request);
5589    
5590                    boolean alwaysAllowDoAsUser = false;
5591    
5592                    if (actionName.equals("addFile") ||
5593                            mvcRenderCommandName.equals("/document_library/edit_file_entry") ||
5594                            path.equals("/portal/session_click") ||
5595                            isAlwaysAllowDoAsUser(
5596                                    actionName, mvcRenderCommandName, path, strutsAction)) {
5597    
5598                            try {
5599                                    alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5600                            }
5601                            catch (Exception e) {
5602                                    _log.error(e, e);
5603                            }
5604                    }
5605    
5606                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5607                             PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5608                            alwaysAllowDoAsUser) {
5609    
5610                            String doAsUserIdString = ParamUtil.getString(
5611                                    request, "doAsUserId");
5612    
5613                            try {
5614                                    long doAsUserId = getDoAsUserId(
5615                                            request, doAsUserIdString, alwaysAllowDoAsUser);
5616    
5617                                    if (doAsUserId > 0) {
5618                                            if (_log.isDebugEnabled()) {
5619                                                    _log.debug("Impersonating user " + doAsUserId);
5620                                            }
5621    
5622                                            return doAsUserId;
5623                                    }
5624                            }
5625                            catch (Exception e) {
5626                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
5627                            }
5628                    }
5629    
5630                    HttpSession session = request.getSession();
5631    
5632                    userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5633    
5634                    if (userIdObj != null) {
5635                            request.setAttribute(WebKeys.USER_ID, userIdObj);
5636    
5637                            return userIdObj.longValue();
5638                    }
5639                    else {
5640                            return 0;
5641                    }
5642            }
5643    
5644            @Override
5645            public long getUserId(PortletRequest portletRequest) {
5646                    return getUserId(getHttpServletRequest(portletRequest));
5647            }
5648    
5649            @Override
5650            public String getUserName(BaseModel<?> baseModel) {
5651                    long userId = 0;
5652                    String userName = StringPool.BLANK;
5653    
5654                    if (baseModel instanceof AuditedModel) {
5655                            AuditedModel auditedModel = (AuditedModel)baseModel;
5656    
5657                            userId = auditedModel.getUserId();
5658                            userName = auditedModel.getUserName();
5659                    }
5660                    else {
5661                            userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5662                            userName = BeanPropertiesUtil.getStringSilent(
5663                                    baseModel, "userName");
5664                    }
5665    
5666                    if (userId == 0) {
5667                            return StringPool.BLANK;
5668                    }
5669    
5670                    if (baseModel.isEscapedModel()) {
5671                            userName = HtmlUtil.unescape(userName);
5672                    }
5673    
5674                    userName = getUserName(userId, userName);
5675    
5676                    if (baseModel.isEscapedModel()) {
5677                            userName = HtmlUtil.escape(userName);
5678                    }
5679    
5680                    return userName;
5681            }
5682    
5683            @Override
5684            public String getUserName(long userId, String defaultUserName) {
5685                    return getUserName(
5686                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5687            }
5688    
5689            @Override
5690            public String getUserName(
5691                    long userId, String defaultUserName, HttpServletRequest request) {
5692    
5693                    return getUserName(
5694                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5695            }
5696    
5697            @Override
5698            public String getUserName(
5699                    long userId, String defaultUserName, String userAttribute) {
5700    
5701                    return getUserName(userId, defaultUserName, userAttribute, null);
5702            }
5703    
5704            @Override
5705            public String getUserName(
5706                    long userId, String defaultUserName, String userAttribute,
5707                    HttpServletRequest request) {
5708    
5709                    String userName = defaultUserName;
5710    
5711                    try {
5712                            User user = UserLocalServiceUtil.getUserById(userId);
5713    
5714                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5715                                    userName = user.getFullName();
5716                            }
5717                            else {
5718                                    userName = user.getScreenName();
5719                            }
5720    
5721                            if (request != null) {
5722                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5723    
5724                                    PortletURL portletURL = new PortletURLImpl(
5725                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
5726                                            PortletRequest.RENDER_PHASE);
5727    
5728                                    portletURL.setParameter(
5729                                            "struts_action", "/directory/view_user");
5730                                    portletURL.setParameter(
5731                                            "p_u_i_d", String.valueOf(user.getUserId()));
5732                                    portletURL.setPortletMode(PortletMode.VIEW);
5733                                    portletURL.setWindowState(WindowState.MAXIMIZED);
5734    
5735                                    userName =
5736                                            "<a href=\"" + portletURL.toString() + "\">" +
5737                                                    HtmlUtil.escape(userName) + "</a>";
5738                            }
5739                    }
5740                    catch (Exception e) {
5741                    }
5742    
5743                    return userName;
5744            }
5745    
5746            @Override
5747            public String getUserPassword(HttpServletRequest request) {
5748                    HttpSession session = request.getSession();
5749    
5750                    return getUserPassword(session);
5751            }
5752    
5753            @Override
5754            public String getUserPassword(HttpSession session) {
5755                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5756            }
5757    
5758            @Override
5759            public String getUserPassword(PortletRequest portletRequest) {
5760                    return getUserPassword(getHttpServletRequest(portletRequest));
5761            }
5762    
5763            /**
5764             * @deprecated As of 7.0.0, with no direct replacement
5765             */
5766            @Deprecated
5767            @Override
5768            public String getUserValue(long userId, String param, String defaultValue) {
5769                    if (Validator.isNotNull(defaultValue)) {
5770                            return defaultValue;
5771                    }
5772    
5773                    try {
5774                            User user = UserLocalServiceUtil.getUserById(userId);
5775    
5776                            return BeanPropertiesUtil.getString(user, param, defaultValue);
5777                    }
5778                    catch (PortalException pe) {
5779                            return StringPool.BLANK;
5780                    }
5781            }
5782    
5783            @Override
5784            public String getValidPortalDomain(long companyId, String domain) {
5785                    if (_validPortalDomainCheckDisabled) {
5786                            return domain;
5787                    }
5788    
5789                    for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
5790                            if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
5791                                    StringUtil.wildcardMatches(
5792                                            domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
5793                                            CharPool.PERCENT, false)) {
5794    
5795                                    return domain;
5796                            }
5797                    }
5798    
5799                    if (_log.isWarnEnabled()) {
5800                            _log.warn(
5801                                    "Set the property \"" + PropsKeys.VIRTUAL_HOSTS_VALID_HOSTS +
5802                                            "\" in portal.properties to allow \"" + domain +
5803                                                    "\" as a domain");
5804                    }
5805    
5806                    try {
5807                            Company company = CompanyLocalServiceUtil.getCompanyById(
5808                                    getDefaultCompanyId());
5809    
5810                            return company.getVirtualHostname();
5811                    }
5812                    catch (Exception e) {
5813                            _log.error("Unable to load default portal instance", e);
5814                    }
5815    
5816                    return _LOCALHOST;
5817            }
5818    
5819            @Override
5820            public long getValidUserId(long companyId, long userId)
5821                    throws PortalException {
5822    
5823                    User user = UserLocalServiceUtil.fetchUser(userId);
5824    
5825                    if (user == null) {
5826                            return UserLocalServiceUtil.getDefaultUserId(companyId);
5827                    }
5828    
5829                    if (user.getCompanyId() == companyId) {
5830                            return user.getUserId();
5831                    }
5832    
5833                    return userId;
5834            }
5835    
5836            @Override
5837            public String getVirtualHostname(LayoutSet layoutSet) {
5838                    String virtualHostname = layoutSet.getVirtualHostname();
5839    
5840                    if (Validator.isNull(virtualHostname)) {
5841                            virtualHostname = layoutSet.getCompanyFallbackVirtualHostname();
5842                    }
5843    
5844                    return virtualHostname;
5845            }
5846    
5847            /**
5848             * @deprecated As of 7.0.0, with no direct replacement
5849             */
5850            @Deprecated
5851            @Override
5852            public String getVirtualLayoutActualURL(
5853                            long groupId, boolean privateLayout, String mainPath,
5854                            String friendlyURL, Map<String, String[]> params,
5855                            Map<String, Object> requestContext)
5856                    throws PortalException {
5857    
5858                    FriendlyURLResolver friendlyURLResolver =
5859                            FriendlyURLResolverRegistryUtil.getFriendlyURLResolver(
5860                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
5861    
5862                    if (friendlyURLResolver == null) {
5863                            return null;
5864                    }
5865    
5866                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5867                            "request");
5868    
5869                    long companyId = PortalInstances.getCompanyId(request);
5870    
5871                    return friendlyURLResolver.getActualURL(
5872                            companyId, groupId, privateLayout, mainPath, friendlyURL, params,
5873                            requestContext);
5874            }
5875    
5876            /**
5877             * @deprecated As of 7.0.0, with no direct replacement
5878             */
5879            @Deprecated
5880            @Override
5881            public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5882                            boolean privateLayout, String friendlyURL,
5883                            Map<String, String[]> params, Map<String, Object> requestContext)
5884                    throws PortalException {
5885    
5886                    FriendlyURLResolver friendlyURLResolver =
5887                            FriendlyURLResolverRegistryUtil.getFriendlyURLResolver(
5888                                    VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
5889    
5890                    if (friendlyURLResolver == null) {
5891                            return null;
5892                    }
5893    
5894                    HttpServletRequest request = (HttpServletRequest)requestContext.get(
5895                            "request");
5896    
5897                    long companyId = PortalInstances.getCompanyId(request);
5898    
5899                    return friendlyURLResolver.getLayoutFriendlyURLComposite(
5900                            companyId, 0, privateLayout, friendlyURL, params, requestContext);
5901            }
5902    
5903            @Override
5904            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5905                    throws PortalException {
5906    
5907                    return getServletURL(
5908                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5909            }
5910    
5911            @Override
5912            public void initCustomSQL() {
5913                    _customSqlKeys = new String[] {
5914                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5915                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5916                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5917                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5918                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5919                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5920                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5921                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5922                                    "DLFILEENTRY$]",
5923                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5924                                    "DLFOLDER$]",
5925                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5926                                    "MBMESSAGE$]",
5927                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5928                                    "MBTHREAD$]",
5929                            "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5930                            "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5931                            "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5932                            "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5933                            "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5934                            "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5935                            "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5936                            "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5937                            "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5938                            "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5939                            "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5940                            "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5941                            "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5942                            "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5943                    };
5944    
5945                    DB db = DBManagerUtil.getDB();
5946    
5947                    Object[] customSqlValues = new Object[] {
5948                            getClassNameId(Group.class), getClassNameId(Layout.class),
5949                            getClassNameId(Organization.class), getClassNameId(Role.class),
5950                            getClassNameId(User.class), getClassNameId(UserGroup.class),
5951                            getClassNameId(BlogsEntry.class), getClassNameId(DLFileEntry.class),
5952                            getClassNameId(DLFolder.class), getClassNameId(MBMessage.class),
5953                            getClassNameId(MBThread.class), ResourceConstants.SCOPE_COMPANY,
5954                            ResourceConstants.SCOPE_GROUP,
5955                            ResourceConstants.SCOPE_GROUP_TEMPLATE,
5956                            ResourceConstants.SCOPE_INDIVIDUAL,
5957                            SocialRelationConstants.TYPE_BI_COWORKER,
5958                            SocialRelationConstants.TYPE_BI_FRIEND,
5959                            SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5960                            SocialRelationConstants.TYPE_BI_SIBLING,
5961                            SocialRelationConstants.TYPE_BI_SPOUSE,
5962                            SocialRelationConstants.TYPE_UNI_CHILD,
5963                            SocialRelationConstants.TYPE_UNI_ENEMY,
5964                            SocialRelationConstants.TYPE_UNI_FOLLOWER,
5965                            SocialRelationConstants.TYPE_UNI_PARENT,
5966                            SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5967                            SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5968                            db.getTemplateTrue()
5969                    };
5970    
5971                    _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5972            }
5973    
5974            @Override
5975            public User initUser(HttpServletRequest request) throws Exception {
5976                    User user = null;
5977    
5978                    try {
5979                            user = getUser(request);
5980                    }
5981                    catch (NoSuchUserException nsue) {
5982                            if (_log.isWarnEnabled()) {
5983                                    _log.warn(nsue.getMessage());
5984                            }
5985    
5986                            long userId = getUserId(request);
5987    
5988                            if (userId > 0) {
5989                                    HttpSession session = request.getSession();
5990    
5991                                    session.invalidate();
5992                            }
5993    
5994                            throw nsue;
5995                    }
5996    
5997                    if (user != null) {
5998                            return user;
5999                    }
6000    
6001                    Company company = getCompany(request);
6002    
6003                    return company.getDefaultUser();
6004            }
6005    
6006            /**
6007             * @deprecated As of 7.0.0, with no direct replacement
6008             */
6009            @Deprecated
6010            @Override
6011            public void invokeTaglibDiscussion(
6012                            PortletConfig portletConfig, ActionRequest actionRequest,
6013                            ActionResponse actionResponse)
6014                    throws Exception {
6015    
6016                    _editDiscussionStrutsAction.execute(
6017                            getHttpServletRequest(actionRequest),
6018                            getHttpServletResponse(actionResponse));
6019            }
6020    
6021            /**
6022             * @deprecated As of 7.0.0, with no direct replacement
6023             */
6024            @Deprecated
6025            @Override
6026            public void invokeTaglibDiscussionPagination(
6027                            PortletConfig portletConfig, ResourceRequest resourceRequest,
6028                            ResourceResponse resourceResponse)
6029                    throws IOException, PortletException {
6030    
6031                    try {
6032                            _getCommentsStrutsAction.execute(
6033                                    getHttpServletRequest(resourceRequest),
6034                                    getHttpServletResponse(resourceResponse));
6035                    }
6036                    catch (IOException | PortletException | RuntimeException e) {
6037                            throw e;
6038                    }
6039                    catch (Exception e) {
6040                            throw new PortletException(e);
6041                    }
6042            }
6043    
6044            /**
6045             * @deprecated As of 6.2.0, with no direct replacement
6046             */
6047            @Deprecated
6048            @Override
6049            public boolean isAllowAddPortletDefaultResource(
6050                            HttpServletRequest request, Portlet portlet)
6051                    throws PortalException {
6052    
6053                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6054                            WebKeys.THEME_DISPLAY);
6055    
6056                    Layout layout = themeDisplay.getLayout();
6057                    LayoutTypePortlet layoutTypePortlet =
6058                            themeDisplay.getLayoutTypePortlet();
6059    
6060                    String portletId = portlet.getPortletId();
6061    
6062                    Boolean renderPortletResource = (Boolean)request.getAttribute(
6063                            WebKeys.RENDER_PORTLET_RESOURCE);
6064    
6065                    if (renderPortletResource != null) {
6066                            boolean runtimePortlet = renderPortletResource.booleanValue();
6067    
6068                            if (runtimePortlet) {
6069                                    return true;
6070                            }
6071                    }
6072    
6073                    if (layout.isTypePanel() &&
6074                            isPanelSelectedPortlet(themeDisplay, portletId)) {
6075    
6076                            return true;
6077                    }
6078    
6079                    if (layout.isTypeControlPanel() &&
6080                            isControlPanelPortlet(portletId, themeDisplay)) {
6081    
6082                            return true;
6083                    }
6084    
6085                    if ((layoutTypePortlet != null) &&
6086                            layoutTypePortlet.hasPortletId(portletId)) {
6087    
6088                            return true;
6089                    }
6090    
6091                    if (themeDisplay.isSignedIn() &&
6092                            portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
6093    
6094                            PermissionChecker permissionChecker =
6095                                    themeDisplay.getPermissionChecker();
6096    
6097                            Group group = layout.getGroup();
6098    
6099                            if (group.isSite()) {
6100                                    if (LayoutPermissionUtil.contains(
6101                                                    permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
6102                                            LayoutPermissionUtil.contains(
6103                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
6104    
6105                                            return true;
6106                                    }
6107                            }
6108    
6109                            if (group.isCompany()) {
6110                                    if (permissionChecker.isCompanyAdmin()) {
6111                                            return true;
6112                                    }
6113                            }
6114                            else if (group.isLayoutPrototype()) {
6115                                    long layoutPrototypeId = group.getClassPK();
6116    
6117                                    if (LayoutPrototypePermissionUtil.contains(
6118                                                    permissionChecker, layoutPrototypeId,
6119                                                    ActionKeys.UPDATE)) {
6120    
6121                                            return true;
6122                                    }
6123                            }
6124                            else if (group.isLayoutSetPrototype()) {
6125                                    long layoutSetPrototypeId = group.getClassPK();
6126    
6127                                    if (LayoutSetPrototypePermissionUtil.contains(
6128                                                    permissionChecker, layoutSetPrototypeId,
6129                                                    ActionKeys.UPDATE)) {
6130    
6131                                            return true;
6132                                    }
6133                            }
6134                            else if (group.isOrganization()) {
6135                                    long organizationId = group.getOrganizationId();
6136    
6137                                    if (OrganizationPermissionUtil.contains(
6138                                                    permissionChecker, organizationId, ActionKeys.UPDATE)) {
6139    
6140                                            return true;
6141                                    }
6142                            }
6143                            else if (group.isUserGroup()) {
6144                                    long scopeGroupId = themeDisplay.getScopeGroupId();
6145    
6146                                    if (GroupPermissionUtil.contains(
6147                                                    permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
6148    
6149                                            return true;
6150                                    }
6151                            }
6152                            else if (group.isUser()) {
6153                                    return true;
6154                            }
6155                    }
6156    
6157                    if (!portlet.isAddDefaultResource()) {
6158                            return false;
6159                    }
6160    
6161                    if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
6162                            return true;
6163                    }
6164    
6165                    if (AuthTokenUtil.isValidPortletInvocationToken(
6166                                    request, layout, portlet)) {
6167    
6168                            return true;
6169                    }
6170    
6171                    return false;
6172            }
6173    
6174            @Override
6175            public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
6176                    throws PortalException {
6177    
6178                    Company company = getCompany(request);
6179    
6180                    return isCDNDynamicResourcesEnabled(company.getCompanyId());
6181            }
6182    
6183            @Override
6184            public boolean isCDNDynamicResourcesEnabled(long companyId) {
6185                    try {
6186                            return PrefsPropsUtil.getBoolean(
6187                                    companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
6188                                    PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
6189                    }
6190                    catch (SystemException se) {
6191                    }
6192    
6193                    return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
6194            }
6195    
6196            /**
6197             * @deprecated As of 6.1.0, renamed to {@link #isGroupAdmin(User, long)}
6198             */
6199            @Deprecated
6200            @Override
6201            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
6202                    return isGroupAdmin(user, groupId);
6203            }
6204    
6205            /**
6206             * @deprecated As of 6.1.0, renamed to {@link #isGroupOwner(User, long)}
6207             */
6208            @Deprecated
6209            @Override
6210            public boolean isCommunityOwner(User user, long groupId) throws Exception {
6211                    return isGroupOwner(user, groupId);
6212            }
6213    
6214            @Override
6215            public boolean isCompanyAdmin(User user) throws Exception {
6216                    PermissionChecker permissionChecker =
6217                            PermissionCheckerFactoryUtil.create(user);
6218    
6219                    return permissionChecker.isCompanyAdmin();
6220            }
6221    
6222            @Override
6223            public boolean isCompanyControlPanelPortlet(
6224                            String portletId, String category, ThemeDisplay themeDisplay)
6225                    throws PortalException {
6226    
6227                    PermissionChecker permissionChecker =
6228                            themeDisplay.getPermissionChecker();
6229    
6230                    if (permissionChecker.isCompanyAdmin()) {
6231                            return true;
6232                    }
6233    
6234                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6235                            themeDisplay.getCompanyId());
6236    
6237                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6238    
6239                    return isControlPanelPortlet(portletId, category, themeDisplay);
6240            }
6241    
6242            @Override
6243            public boolean isCompanyControlPanelPortlet(
6244                            String portletId, ThemeDisplay themeDisplay)
6245                    throws PortalException {
6246    
6247                    PermissionChecker permissionChecker =
6248                            themeDisplay.getPermissionChecker();
6249    
6250                    if (permissionChecker.isCompanyAdmin()) {
6251                            return true;
6252                    }
6253    
6254                    Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6255                            themeDisplay.getCompanyId());
6256    
6257                    themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6258    
6259                    return isControlPanelPortlet(portletId, themeDisplay);
6260            }
6261    
6262            @Override
6263            public boolean isControlPanelPortlet(
6264                    String portletId, String category, ThemeDisplay themeDisplay) {
6265    
6266                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
6267                            themeDisplay.getCompanyId(), portletId);
6268    
6269                    String controlPanelEntryCategory =
6270                            portlet.getControlPanelEntryCategory();
6271    
6272                    if (controlPanelEntryCategory.equals(category) ||
6273                            (category.endsWith(StringPool.PERIOD) &&
6274                             StringUtil.startsWith(controlPanelEntryCategory, category))) {
6275    
6276                            return isControlPanelPortlet(portletId, themeDisplay);
6277                    }
6278    
6279                    return false;
6280            }
6281    
6282            @Override
6283            public boolean isControlPanelPortlet(
6284                    String portletId, ThemeDisplay themeDisplay) {
6285    
6286                    try {
6287                            return PortletPermissionUtil.hasControlPanelAccessPermission(
6288                                    themeDisplay.getPermissionChecker(),
6289                                    themeDisplay.getScopeGroupId(), portletId);
6290                    }
6291                    catch (PortalException pe) {
6292                            if (_log.isWarnEnabled()) {
6293                                    _log.warn(
6294                                            "Unable to check control panel access permission", pe);
6295                            }
6296                    }
6297    
6298                    return false;
6299            }
6300    
6301            @Override
6302            public boolean isGroupAdmin(User user, long groupId) throws Exception {
6303                    PermissionChecker permissionChecker =
6304                            PermissionCheckerFactoryUtil.create(user);
6305    
6306                    return permissionChecker.isGroupAdmin(groupId);
6307            }
6308    
6309            @Override
6310            public boolean isGroupFriendlyURL(
6311                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6312    
6313                    if (fullURL.endsWith(groupFriendlyURL) &&
6314                            !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6315    
6316                            return true;
6317                    }
6318    
6319                    return false;
6320            }
6321    
6322            @Override
6323            public boolean isGroupOwner(User user, long groupId) throws Exception {
6324                    PermissionChecker permissionChecker =
6325                            PermissionCheckerFactoryUtil.create(user);
6326    
6327                    return permissionChecker.isGroupOwner(groupId);
6328            }
6329    
6330            @Override
6331            public boolean isLayoutDescendant(Layout layout, long layoutId)
6332                    throws PortalException {
6333    
6334                    if (layout.getLayoutId() == layoutId) {
6335                            return true;
6336                    }
6337    
6338                    for (Layout childLayout : layout.getChildren()) {
6339                            if (isLayoutDescendant(childLayout, layoutId)) {
6340                                    return true;
6341                            }
6342                    }
6343    
6344                    return false;
6345            }
6346    
6347            @Override
6348            public boolean isLayoutSitemapable(Layout layout) {
6349                    if (layout.isPrivateLayout()) {
6350                            return false;
6351                    }
6352    
6353                    LayoutType layoutType = layout.getLayoutType();
6354    
6355                    return layoutType.isSitemapable();
6356            }
6357    
6358            @Override
6359            public boolean isLoginRedirectRequired(HttpServletRequest request) {
6360                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6361                            !request.isSecure()) {
6362    
6363                            return true;
6364                    }
6365    
6366                    long companyId = getCompanyId(request);
6367    
6368                    if (SSOUtil.isLoginRedirectRequired(companyId)) {
6369                            return true;
6370                    }
6371    
6372                    return false;
6373            }
6374    
6375            @Override
6376            public boolean isMethodGet(PortletRequest portletRequest) {
6377                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6378    
6379                    String method = GetterUtil.getString(request.getMethod());
6380    
6381                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6382                            return true;
6383                    }
6384                    else {
6385                            return false;
6386                    }
6387            }
6388    
6389            @Override
6390            public boolean isMethodPost(PortletRequest portletRequest) {
6391                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6392    
6393                    String method = GetterUtil.getString(request.getMethod());
6394    
6395                    if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6396                            return true;
6397                    }
6398                    else {
6399                            return false;
6400                    }
6401            }
6402    
6403            @Override
6404            public boolean isMultipartRequest(HttpServletRequest request) {
6405                    String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6406    
6407                    if ((contentType != null) &&
6408                            contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6409    
6410                            return true;
6411                    }
6412                    else {
6413                            return false;
6414                    }
6415            }
6416    
6417            @Override
6418            public boolean isOmniadmin(long userId) {
6419                    return OmniadminUtil.isOmniadmin(userId);
6420            }
6421    
6422            @Override
6423            public boolean isOmniadmin(User user) {
6424                    return OmniadminUtil.isOmniadmin(user);
6425            }
6426    
6427            @Override
6428            public boolean isReservedParameter(String name) {
6429                    return _reservedParams.contains(name);
6430            }
6431    
6432            @Override
6433            public boolean isRightToLeft(HttpServletRequest request) {
6434                    String languageId = LanguageUtil.getLanguageId(request);
6435    
6436                    Locale locale = LocaleUtil.fromLanguageId(languageId);
6437    
6438                    String langDir = LanguageUtil.get(locale, "lang.dir");
6439    
6440                    return langDir.equals("rtl");
6441            }
6442    
6443            @Override
6444            public boolean isRSSFeedsEnabled() {
6445                    return PropsValues.RSS_FEEDS_ENABLED;
6446            }
6447    
6448            @Override
6449            public boolean isSecure(HttpServletRequest request) {
6450                    HttpSession session = request.getSession();
6451    
6452                    if (session == null) {
6453                            return request.isSecure();
6454                    }
6455    
6456                    Boolean httpsInitial = (Boolean)session.getAttribute(
6457                            WebKeys.HTTPS_INITIAL);
6458    
6459                    boolean secure = false;
6460    
6461                    if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6462                            !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6463                            (httpsInitial != null) && !httpsInitial.booleanValue()) {
6464    
6465                            secure = false;
6466                    }
6467                    else {
6468                            secure = request.isSecure();
6469                    }
6470    
6471                    return secure;
6472            }
6473    
6474            @Override
6475            public boolean isSystemGroup(String groupName) {
6476                    if (groupName == null) {
6477                            return false;
6478                    }
6479    
6480                    groupName = groupName.trim();
6481    
6482                    int pos = Arrays.binarySearch(
6483                            _sortedSystemGroups, groupName, new StringComparator());
6484    
6485                    if (pos >= 0) {
6486                            return true;
6487                    }
6488                    else {
6489                            return false;
6490                    }
6491            }
6492    
6493            @Override
6494            public boolean isSystemRole(String roleName) {
6495                    if (roleName == null) {
6496                            return false;
6497                    }
6498    
6499                    roleName = roleName.trim();
6500    
6501                    int pos = Arrays.binarySearch(
6502                            _sortedSystemRoles, roleName, new StringComparator());
6503    
6504                    if (pos >= 0) {
6505                            return true;
6506                    }
6507    
6508                    pos = Arrays.binarySearch(
6509                            _sortedSystemSiteRoles, roleName, new StringComparator());
6510    
6511                    if (pos >= 0) {
6512                            return true;
6513                    }
6514    
6515                    pos = Arrays.binarySearch(
6516                            _sortedSystemOrganizationRoles, roleName, new StringComparator());
6517    
6518                    if (pos >= 0) {
6519                            return true;
6520                    }
6521    
6522                    return false;
6523            }
6524    
6525            @Override
6526            public boolean isUpdateAvailable() {
6527                    return PluginPackageUtil.isUpdateAvailable();
6528            }
6529    
6530            @Override
6531            public boolean isValidResourceId(String resourceId) {
6532                    if (Validator.isNull(resourceId)) {
6533                            return true;
6534                    }
6535    
6536                    Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6537    
6538                    if (matcher.matches()) {
6539                            return false;
6540                    }
6541    
6542                    return true;
6543            }
6544    
6545            @Override
6546            public boolean removePortalInetSocketAddressEventListener(
6547                    PortalInetSocketAddressEventListener
6548                            portalInetSocketAddressEventListener) {
6549    
6550                    return _portalInetSocketAddressEventListeners.remove(
6551                            portalInetSocketAddressEventListener);
6552            }
6553    
6554            /**
6555             * @deprecated As of 7.0.0, replaced by {@link
6556             *             #removePortalInetSocketAddressEventListener(
6557             *             PortalInetSocketAddressEventListener)}
6558             */
6559            @Deprecated
6560            @Override
6561            public void removePortalPortEventListener(
6562                    PortalPortEventListener portalPortEventListener) {
6563    
6564                    _portalPortEventListeners.remove(portalPortEventListener);
6565            }
6566    
6567            @Override
6568            public void resetCDNHosts() {
6569                    _cdnHostHttpMap.clear();
6570                    _cdnHostHttpsMap.clear();
6571    
6572                    if (!ClusterInvokeThreadLocal.isEnabled()) {
6573                            return;
6574                    }
6575    
6576                    ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6577                            _resetCDNHostsMethodHandler, true);
6578    
6579                    try {
6580                            ClusterExecutorUtil.execute(clusterRequest);
6581                    }
6582                    catch (Exception e) {
6583                            _log.error("Unable to clear cluster wide CDN hosts", e);
6584                    }
6585            }
6586    
6587            /**
6588             * @deprecated As of 6.2.0, replaced by {@link
6589             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelist}
6590             */
6591            @Deprecated
6592            @Override
6593            public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6594                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6595            }
6596    
6597            /**
6598             * @deprecated As of 6.2.0, replaced by {@link
6599             *             AuthTokenWhitelistUtil#resetPortletInvocationWhitelistActions}
6600             */
6601            @Deprecated
6602            @Override
6603            public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6604                    return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6605            }
6606    
6607            @Override
6608            public String resetPortletParameters(String url, String portletId) {
6609                    if (Validator.isNull(url) || Validator.isNull(portletId)) {
6610                            return url;
6611                    }
6612    
6613                    String portletNamespace = getPortletNamespace(portletId);
6614    
6615                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(url);
6616    
6617                    for (String name : parameterMap.keySet()) {
6618                            if (name.startsWith(portletNamespace)) {
6619                                    url = HttpUtil.removeParameter(url, name);
6620                            }
6621                    }
6622    
6623                    return url;
6624            }
6625    
6626            @Override
6627            public void sendError(
6628                            Exception e, ActionRequest actionRequest,
6629                            ActionResponse actionResponse)
6630                    throws IOException {
6631    
6632                    sendError(0, e, actionRequest, actionResponse);
6633            }
6634    
6635            @Override
6636            public void sendError(
6637                            Exception e, HttpServletRequest request,
6638                            HttpServletResponse response)
6639                    throws IOException, ServletException {
6640    
6641                    sendError(0, e, request, response);
6642            }
6643    
6644            @Override
6645            public void sendError(
6646                            int status, Exception e, ActionRequest actionRequest,
6647                            ActionResponse actionResponse)
6648                    throws IOException {
6649    
6650                    StringBundler sb = new StringBundler(7);
6651    
6652                    sb.append(_pathMain);
6653                    sb.append("/portal/status?status=");
6654                    sb.append(status);
6655                    sb.append("&exception=");
6656                    sb.append(e.getClass().getName());
6657                    sb.append("&previousURL=");
6658                    sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6659    
6660                    actionResponse.sendRedirect(sb.toString());
6661            }
6662    
6663            @Override
6664            public void sendError(
6665                            int status, Exception e, HttpServletRequest request,
6666                            HttpServletResponse response)
6667                    throws IOException, ServletException {
6668    
6669                    if (_log.isDebugEnabled()) {
6670                            String currentURL = (String)request.getAttribute(
6671                                    WebKeys.CURRENT_URL);
6672    
6673                            _log.debug(
6674                                    "Current URL " + currentURL + " generates exception: " +
6675                                            e.getMessage());
6676                    }
6677    
6678                    if (e instanceof NoSuchImageException) {
6679                            if (_logWebServerServlet.isWarnEnabled()) {
6680                                    _logWebServerServlet.warn(e, e);
6681                            }
6682                    }
6683                    else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6684                            if ((e instanceof NoSuchLayoutException) ||
6685                                    (e instanceof PrincipalException)) {
6686    
6687                                    String msg = e.getMessage();
6688    
6689                                    if (Validator.isNotNull(msg)) {
6690                                            _log.debug(msg);
6691                                    }
6692                            }
6693                            else {
6694                                    _log.debug(e, e);
6695                            }
6696                    }
6697                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6698                            _log.warn(e, e);
6699                    }
6700    
6701                    if (response.isCommitted()) {
6702                            return;
6703                    }
6704    
6705                    if (status == 0) {
6706                            if (e instanceof PrincipalException) {
6707                                    status = HttpServletResponse.SC_FORBIDDEN;
6708                            }
6709                            else {
6710                                    String name = e.getClass().getName();
6711    
6712                                    name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6713    
6714                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6715                                            status = HttpServletResponse.SC_NOT_FOUND;
6716                                    }
6717                            }
6718    
6719                            if (status == 0) {
6720                                    status = HttpServletResponse.SC_BAD_REQUEST;
6721                            }
6722                    }
6723    
6724                    String redirect = null;
6725    
6726                    if ((e instanceof NoSuchGroupException) &&
6727                            Validator.isNotNull(
6728                                    PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6729    
6730                            redirect = PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND;
6731                    }
6732                    else if ((e instanceof NoSuchLayoutException) &&
6733                                     Validator.isNotNull(
6734                                             PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6735    
6736                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6737                    }
6738                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6739                            redirect = PATH_MAIN + "/portal/status";
6740                    }
6741    
6742                    if (Validator.equals(redirect, request.getRequestURI())) {
6743                            if (_log.isWarnEnabled()) {
6744                                    _log.warn("Unable to redirect to missing URI: " + redirect);
6745                            }
6746    
6747                            redirect = null;
6748                    }
6749    
6750                    if (Validator.isNotNull(redirect)) {
6751                            HttpSession session = PortalSessionThreadLocal.getHttpSession();
6752    
6753                            if (session == null) {
6754                                    session = request.getSession();
6755                            }
6756    
6757                            response.setStatus(status);
6758    
6759                            SessionErrors.add(session, e.getClass(), e);
6760    
6761                            ServletContext servletContext = session.getServletContext();
6762    
6763                            RequestDispatcher requestDispatcher =
6764                                    servletContext.getRequestDispatcher(redirect);
6765    
6766                            if (requestDispatcher != null) {
6767                                    requestDispatcher.forward(request, response);
6768                            }
6769                    }
6770                    else if (e != null) {
6771                            response.sendError(status, e.getMessage());
6772                    }
6773                    else {
6774                            String currentURL = (String)request.getAttribute(
6775                                    WebKeys.CURRENT_URL);
6776    
6777                            response.sendError(status, "Current URL " + currentURL);
6778                    }
6779            }
6780    
6781            @Override
6782            public void sendRSSFeedsDisabledError(
6783                            HttpServletRequest request, HttpServletResponse response)
6784                    throws IOException, ServletException {
6785    
6786                    sendError(
6787                            HttpServletResponse.SC_NOT_FOUND, new RSSFeedException(), request,
6788                            response);
6789            }
6790    
6791            @Override
6792            public void sendRSSFeedsDisabledError(
6793                            PortletRequest portletRequest, PortletResponse portletResponse)
6794                    throws IOException, ServletException {
6795    
6796                    HttpServletRequest request = getHttpServletRequest(portletRequest);
6797                    HttpServletResponse response = getHttpServletResponse(portletResponse);
6798    
6799                    sendRSSFeedsDisabledError(request, response);
6800            }
6801    
6802            @Override
6803            public void setPageDescription(
6804                    String description, HttpServletRequest request) {
6805    
6806                    ListMergeable<String> descriptionListMergeable = new ListMergeable<>();
6807    
6808                    descriptionListMergeable.add(description);
6809    
6810                    request.setAttribute(
6811                            WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6812            }
6813    
6814            @Override
6815            public void setPageKeywords(String keywords, HttpServletRequest request) {
6816                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6817    
6818                    addPageKeywords(keywords, request);
6819            }
6820    
6821            @Override
6822            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6823                    ListMergeable<String> subtitleListMergeable = new ListMergeable<>();
6824    
6825                    subtitleListMergeable.add(subtitle);
6826    
6827                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6828            }
6829    
6830            @Override
6831            public void setPageTitle(String title, HttpServletRequest request) {
6832                    ListMergeable<String> titleListMergeable = new ListMergeable<>();
6833    
6834                    titleListMergeable.add(title);
6835    
6836                    request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6837            }
6838    
6839            @Override
6840            public void setPortalInetSocketAddresses(HttpServletRequest request) {
6841                    boolean secure = request.isSecure();
6842    
6843                    if ((secure && (_securePortalLocalInetSocketAddress.get() != null) &&
6844                             (_securePortalServerInetSocketAddress.get() != null)) ||
6845                            (!secure && (_portalLocalInetSocketAddress.get() != null) &&
6846                             (_portalServerInetSocketAddress.get() != null))) {
6847    
6848                            return;
6849                    }
6850    
6851                    InetAddress localInetAddress = null;
6852                    InetAddress serverInetAddress = null;
6853    
6854                    try {
6855                            localInetAddress = InetAddress.getByName(request.getLocalAddr());
6856                            serverInetAddress = InetAddress.getByName(request.getServerName());
6857                    }
6858                    catch (UnknownHostException uhe) {
6859                            if (_log.isWarnEnabled()) {
6860                                    _log.warn("Unable to resolve portal host", uhe);
6861                            }
6862    
6863                            return;
6864                    }
6865    
6866                    InetSocketAddress localInetSocketAddress = new InetSocketAddress(
6867                            localInetAddress, request.getLocalPort());
6868                    InetSocketAddress serverInetSocketAddress = new InetSocketAddress(
6869                            serverInetAddress, request.getServerPort());
6870    
6871                    if (secure) {
6872                            if (_securePortalLocalInetSocketAddress.compareAndSet(
6873                                            null, localInetSocketAddress)) {
6874    
6875                                    notifyPortalInetSocketAddressEventListeners(
6876                                            localInetSocketAddress, true, true);
6877                            }
6878    
6879                            if (_securePortalServerInetSocketAddress.compareAndSet(
6880                                            null, serverInetSocketAddress)) {
6881    
6882                                    notifyPortalInetSocketAddressEventListeners(
6883                                            serverInetSocketAddress, false, true);
6884                            }
6885                    }
6886                    else {
6887                            if (_portalLocalInetSocketAddress.compareAndSet(
6888                                            null, localInetSocketAddress)) {
6889    
6890                                    notifyPortalInetSocketAddressEventListeners(
6891                                            localInetSocketAddress, true, false);
6892                            }
6893    
6894                            if (_portalServerInetSocketAddress.compareAndSet(
6895                                            null, serverInetSocketAddress)) {
6896    
6897                                    notifyPortalInetSocketAddressEventListeners(
6898                                            serverInetSocketAddress, false, false);
6899                            }
6900                    }
6901            }
6902    
6903            /**
6904             * Sets the port obtained on the first request to the portal.
6905             *
6906             * @deprecated As of 7.0.0, replaced by {@link
6907             *             #setPortalInetSocketAddresses(HttpServletRequest)}
6908             */
6909            @Deprecated
6910            @Override
6911            public void setPortalPort(HttpServletRequest request) {
6912                    if (request.isSecure()) {
6913                            if (_securePortalPort.get() == -1) {
6914                                    int securePortalPort = request.getServerPort();
6915    
6916                                    if (_securePortalPort.compareAndSet(-1, securePortalPort) &&
6917                                            StringUtil.equalsIgnoreCase(
6918                                                    Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL)) {
6919    
6920                                            notifyPortalPortEventListeners(securePortalPort);
6921                                    }
6922                            }
6923                    }
6924                    else {
6925                            if (_portalPort.get() == -1) {
6926                                    int portalPort = request.getServerPort();
6927    
6928                                    if (_portalPort.compareAndSet(-1, portalPort)) {
6929                                            notifyPortalPortEventListeners(portalPort);
6930                                    }
6931                            }
6932                    }
6933            }
6934    
6935            @Override
6936            public void storePreferences(PortletPreferences portletPreferences)
6937                    throws IOException, ValidatorException {
6938    
6939                    PortletPreferencesWrapper portletPreferencesWrapper =
6940                            (PortletPreferencesWrapper)portletPreferences;
6941    
6942                    PortletPreferencesImpl portletPreferencesImpl =
6943                            portletPreferencesWrapper.getPortletPreferencesImpl();
6944    
6945                    portletPreferencesImpl.store();
6946            }
6947    
6948            @Override
6949            public String[] stripURLAnchor(String url, String separator) {
6950                    String anchor = StringPool.BLANK;
6951    
6952                    int pos = url.indexOf(separator);
6953    
6954                    if (pos != -1) {
6955                            anchor = url.substring(pos);
6956                            url = url.substring(0, pos);
6957                    }
6958    
6959                    return new String[] {url, anchor};
6960            }
6961    
6962            @Override
6963            public String transformCustomSQL(String sql) {
6964                    if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6965                            initCustomSQL();
6966                    }
6967    
6968                    return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6969            }
6970    
6971            @Override
6972            public String transformSQL(String sql) {
6973                    return SQLTransformer.transform(sql);
6974            }
6975    
6976            @Override
6977            public void updateImageId(
6978                            BaseModel<?> baseModel, boolean hasImage, byte[] bytes,
6979                            String fieldName, long maxSize, int maxHeight, int maxWidth)
6980                    throws PortalException {
6981    
6982                    long imageId = BeanPropertiesUtil.getLong(baseModel, fieldName);
6983    
6984                    if (!hasImage) {
6985                            if (imageId > 0) {
6986                                    ImageLocalServiceUtil.deleteImage(imageId);
6987    
6988                                    BeanPropertiesUtil.setProperty(baseModel, fieldName, 0);
6989                            }
6990    
6991                            return;
6992                    }
6993    
6994                    if (ArrayUtil.isEmpty(bytes)) {
6995                            return;
6996                    }
6997    
6998                    if ((maxSize > 0) && (bytes.length > maxSize)) {
6999                            throw new ImageSizeException();
7000                    }
7001    
7002                    if ((maxHeight > 0) || (maxWidth > 0)) {
7003                            try {
7004                                    ImageBag imageBag = ImageToolUtil.read(bytes);
7005    
7006                                    RenderedImage renderedImage = imageBag.getRenderedImage();
7007    
7008                                    if (renderedImage == null) {
7009                                            throw new ImageTypeException();
7010                                    }
7011    
7012                                    renderedImage = ImageToolUtil.scale(
7013                                            renderedImage, maxHeight, maxWidth);
7014    
7015                                    bytes = ImageToolUtil.getBytes(
7016                                            renderedImage, imageBag.getType());
7017                            }
7018                            catch (IOException ioe) {
7019                                    throw new ImageSizeException(ioe);
7020                            }
7021                    }
7022    
7023                    Image image = ImageLocalServiceUtil.moveImage(imageId, bytes);
7024    
7025                    BeanPropertiesUtil.setProperty(
7026                            baseModel, fieldName, image.getImageId());
7027            }
7028    
7029            @Override
7030            public PortletMode updatePortletMode(
7031                            String portletId, User user, Layout layout, PortletMode portletMode,
7032                            HttpServletRequest request)
7033                    throws PortalException {
7034    
7035                    LayoutTypePortlet layoutType =
7036                            (LayoutTypePortlet)layout.getLayoutType();
7037    
7038                    if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
7039                            if (layoutType.hasModeAboutPortletId(portletId)) {
7040                                    return LiferayPortletMode.ABOUT;
7041                            }
7042                            else if (layoutType.hasModeConfigPortletId(portletId)) {
7043                                    return LiferayPortletMode.CONFIG;
7044                            }
7045                            else if (layoutType.hasModeEditPortletId(portletId)) {
7046                                    return PortletMode.EDIT;
7047                            }
7048                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
7049                                    return LiferayPortletMode.EDIT_DEFAULTS;
7050                            }
7051                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
7052                                    return LiferayPortletMode.EDIT_GUEST;
7053                            }
7054                            else if (layoutType.hasModeHelpPortletId(portletId)) {
7055                                    return PortletMode.HELP;
7056                            }
7057                            else if (layoutType.hasModePreviewPortletId(portletId)) {
7058                                    return LiferayPortletMode.PREVIEW;
7059                            }
7060                            else if (layoutType.hasModePrintPortletId(portletId)) {
7061                                    return LiferayPortletMode.PRINT;
7062                            }
7063                            else {
7064                                    return PortletMode.VIEW;
7065                            }
7066                    }
7067                    else {
7068                            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7069                                    WebKeys.THEME_DISPLAY);
7070    
7071                            PermissionChecker permissionChecker =
7072                                    themeDisplay.getPermissionChecker();
7073    
7074                            Portlet portlet = PortletLocalServiceUtil.getPortletById(
7075                                    getCompanyId(request), portletId);
7076    
7077                            if (!PortletPermissionUtil.contains(
7078                                            permissionChecker, getScopeGroupId(request), layout,
7079                                            portlet, ActionKeys.VIEW)) {
7080    
7081                                    return portletMode;
7082                            }
7083    
7084                            boolean updateLayout = false;
7085    
7086                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
7087                                    !layoutType.hasModeAboutPortletId(portletId)) {
7088    
7089                                    layoutType.addModeAboutPortletId(portletId);
7090    
7091                                    updateLayout = true;
7092                            }
7093                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
7094                                             !layoutType.hasModeConfigPortletId(portletId) &&
7095                                             PortletPermissionUtil.contains(
7096                                                     permissionChecker, getScopeGroupId(request), layout,
7097                                                     portlet, ActionKeys.CONFIGURATION)) {
7098    
7099                                    layoutType.addModeConfigPortletId(portletId);
7100    
7101                                    updateLayout = true;
7102                            }
7103                            else if (portletMode.equals(PortletMode.EDIT) &&
7104                                             !layoutType.hasModeEditPortletId(portletId) &&
7105                                             PortletPermissionUtil.contains(
7106                                                     permissionChecker, getScopeGroupId(request), layout,
7107                                                     portlet, ActionKeys.PREFERENCES)) {
7108    
7109                                    layoutType.addModeEditPortletId(portletId);
7110    
7111                                    updateLayout = true;
7112                            }
7113                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
7114                                             !layoutType.hasModeEditDefaultsPortletId(portletId) &&
7115                                             PortletPermissionUtil.contains(
7116                                                     permissionChecker, getScopeGroupId(request), layout,
7117                                                     portlet, ActionKeys.PREFERENCES)) {
7118    
7119                                    layoutType.addModeEditDefaultsPortletId(portletId);
7120    
7121                                    updateLayout = true;
7122                            }
7123                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
7124                                             !layoutType.hasModeEditGuestPortletId(portletId) &&
7125                                             PortletPermissionUtil.contains(
7126                                                     permissionChecker, getScopeGroupId(request), layout,
7127                                                     portlet, ActionKeys.GUEST_PREFERENCES)) {
7128    
7129                                    layoutType.addModeEditGuestPortletId(portletId);
7130    
7131                                    updateLayout = true;
7132                            }
7133                            else if (portletMode.equals(PortletMode.HELP) &&
7134                                             !layoutType.hasModeHelpPortletId(portletId)) {
7135    
7136                                    layoutType.addModeHelpPortletId(portletId);
7137    
7138                                    updateLayout = true;
7139                            }
7140                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
7141                                             !layoutType.hasModePreviewPortletId(portletId)) {
7142    
7143                                    layoutType.addModePreviewPortletId(portletId);
7144    
7145                                    updateLayout = true;
7146                            }
7147                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
7148                                             !layoutType.hasModePrintPortletId(portletId)) {
7149    
7150                                    layoutType.addModePrintPortletId(portletId);
7151    
7152                                    updateLayout = true;
7153                            }
7154                            else if (portletMode.equals(PortletMode.VIEW) &&
7155                                             !layoutType.hasModeViewPortletId(portletId)) {
7156    
7157                                    layoutType.removeModesPortletId(portletId);
7158    
7159                                    updateLayout = true;
7160                            }
7161    
7162                            if (updateLayout) {
7163                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7164    
7165                                    if (layoutClone != null) {
7166                                            layoutClone.update(
7167                                                    request, layout.getPlid(), layout.getTypeSettings());
7168                                    }
7169                            }
7170    
7171                            return portletMode;
7172                    }
7173            }
7174    
7175            @Override
7176            public String updateRedirect(
7177                    String redirect, String oldPath, String newPath) {
7178    
7179                    if (Validator.isNull(redirect) || (oldPath == null) ||
7180                            oldPath.equals(newPath)) {
7181    
7182                            return redirect;
7183                    }
7184    
7185                    String queryString = HttpUtil.getQueryString(redirect);
7186    
7187                    String redirectParam = HttpUtil.getParameter(
7188                            redirect, "redirect", false);
7189    
7190                    if (Validator.isNotNull(redirectParam)) {
7191                            String newRedirectParam = StringUtil.replace(
7192                                    redirectParam, HttpUtil.encodeURL(oldPath),
7193                                    HttpUtil.encodeURL(newPath));
7194    
7195                            queryString = StringUtil.replace(
7196                                    queryString, redirectParam, newRedirectParam);
7197                    }
7198    
7199                    String redirectPath = HttpUtil.getPath(redirect);
7200    
7201                    int pos = redirect.indexOf(redirectPath);
7202    
7203                    String prefix = redirect.substring(0, pos);
7204    
7205                    pos = redirectPath.lastIndexOf(oldPath);
7206    
7207                    if (pos != -1) {
7208                            prefix += redirectPath.substring(0, pos);
7209    
7210                            String suffix = redirectPath.substring(pos + oldPath.length());
7211    
7212                            redirect = prefix + newPath + suffix;
7213                    }
7214                    else {
7215                            redirect = prefix + redirectPath;
7216                    }
7217    
7218                    if (Validator.isNotNull(queryString)) {
7219                            redirect += StringPool.QUESTION + queryString;
7220                    }
7221    
7222                    return redirect;
7223            }
7224    
7225            @Override
7226            public WindowState updateWindowState(
7227                    String portletId, User user, Layout layout, WindowState windowState,
7228                    HttpServletRequest request) {
7229    
7230                    LayoutTypePortlet layoutType =
7231                            (LayoutTypePortlet)layout.getLayoutType();
7232    
7233                    if ((windowState == null) || Validator.isNull(windowState.toString())) {
7234                            if (layoutType.hasStateMaxPortletId(portletId)) {
7235                                    windowState = WindowState.MAXIMIZED;
7236                            }
7237                            else if (layoutType.hasStateMinPortletId(portletId)) {
7238                                    windowState = WindowState.MINIMIZED;
7239                            }
7240                            else {
7241                                    windowState = WindowState.NORMAL;
7242                            }
7243                    }
7244                    else {
7245                            boolean updateLayout = false;
7246    
7247                            if (windowState.equals(WindowState.MAXIMIZED) &&
7248                                    !layoutType.hasStateMaxPortletId(portletId)) {
7249    
7250                                    layoutType.addStateMaxPortletId(portletId);
7251    
7252                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
7253                                            updateLayout = true;
7254                                    }
7255                            }
7256                            else if (windowState.equals(WindowState.MINIMIZED) &&
7257                                             !layoutType.hasStateMinPortletId(portletId)) {
7258    
7259                                    layoutType.addStateMinPortletId(portletId);
7260    
7261                                    updateLayout = true;
7262                            }
7263                            else if (windowState.equals(WindowState.NORMAL) &&
7264                                             !layoutType.hasStateNormalPortletId(portletId)) {
7265    
7266                                    layoutType.removeStatesPortletId(portletId);
7267    
7268                                    updateLayout = true;
7269                            }
7270    
7271                            if (updateLayout) {
7272                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7273    
7274                                    if (layoutClone != null) {
7275                                            layoutClone.update(
7276                                                    request, layout.getPlid(), layout.getTypeSettings());
7277                                    }
7278                            }
7279                    }
7280    
7281                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7282                            WebKeys.THEME_DISPLAY);
7283    
7284                    themeDisplay.setStateExclusive(
7285                            windowState.equals(LiferayWindowState.EXCLUSIVE));
7286                    themeDisplay.setStateMaximized(
7287                            windowState.equals(WindowState.MAXIMIZED));
7288                    themeDisplay.setStatePopUp(
7289                            windowState.equals(LiferayWindowState.POP_UP));
7290    
7291                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
7292    
7293                    return windowState;
7294            }
7295    
7296            protected void addDefaultResource(
7297                            long companyId, Layout layout, Portlet portlet,
7298                            boolean portletActions)
7299                    throws PortalException {
7300    
7301                    long groupId = getScopeGroupId(layout, portlet.getPortletId());
7302    
7303                    addDefaultResource(companyId, groupId, layout, portlet, portletActions);
7304            }
7305    
7306            protected void addDefaultResource(
7307                            long companyId, long groupId, Layout layout, Portlet portlet,
7308                            boolean portletActions)
7309                    throws PortalException {
7310    
7311                    String rootPortletId = portlet.getRootPortletId();
7312    
7313                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
7314                            layout.getPlid(), portlet.getPortletId());
7315    
7316                    String name = null;
7317                    String primaryKey = null;
7318    
7319                    if (portletActions) {
7320                            name = rootPortletId;
7321                            primaryKey = portletPrimaryKey;
7322                    }
7323                    else {
7324                            Group group = GroupLocalServiceUtil.fetchGroup(groupId);
7325    
7326                            if ((group != null) && group.isStagingGroup()) {
7327                                    groupId = group.getLiveGroupId();
7328                            }
7329    
7330                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
7331                            primaryKey = String.valueOf(groupId);
7332                    }
7333    
7334                    if (Validator.isNull(name)) {
7335                            return;
7336                    }
7337    
7338                    int count =
7339                            ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
7340                                    companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
7341                                    primaryKey);
7342    
7343                    if (count > 0) {
7344                            return;
7345                    }
7346    
7347                    boolean addGuestPermissions = true;
7348    
7349                    if (portletActions) {
7350                            Group layoutGroup = layout.getGroup();
7351    
7352                            if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype() &&
7353                                    !layoutGroup.isLayoutSetPrototype()) {
7354    
7355                                    addGuestPermissions = false;
7356                            }
7357                    }
7358    
7359                    ResourceLocalServiceUtil.addResources(
7360                            companyId, groupId, 0, name, primaryKey, portletActions, true,
7361                            addGuestPermissions);
7362            }
7363    
7364            protected String buildI18NPath(Locale locale) {
7365                    String languageId = LocaleUtil.toLanguageId(locale);
7366    
7367                    if (Validator.isNull(languageId)) {
7368                            return null;
7369                    }
7370    
7371                    if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
7372                            Locale priorityLocale = LanguageUtil.getLocale(
7373                                    locale.getLanguage());
7374    
7375                            if (locale.equals(priorityLocale)) {
7376                                    languageId = locale.getLanguage();
7377                            }
7378                    }
7379                    else {
7380                            languageId = locale.getLanguage();
7381                    }
7382    
7383                    return StringPool.SLASH.concat(languageId);
7384            }
7385    
7386            protected Set<Group> doGetAncestorSiteGroups(
7387                            long groupId, boolean checkContentSharingWithChildrenEnabled)
7388                    throws PortalException {
7389    
7390                    Set<Group> groups = new LinkedHashSet<>();
7391    
7392                    long siteGroupId = getSiteGroupId(groupId);
7393    
7394                    Group siteGroup = GroupLocalServiceUtil.fetchGroup(siteGroupId);
7395    
7396                    if (siteGroup == null) {
7397                            return groups;
7398                    }
7399    
7400                    for (Group group : siteGroup.getAncestors()) {
7401                            if (checkContentSharingWithChildrenEnabled &&
7402                                    !SitesUtil.isContentSharingWithChildrenEnabled(group)) {
7403    
7404                                    continue;
7405                            }
7406    
7407                            groups.add(group);
7408                    }
7409    
7410                    if (!siteGroup.isCompany()) {
7411                            groups.add(
7412                                    GroupLocalServiceUtil.getCompanyGroup(
7413                                            siteGroup.getCompanyId()));
7414                    }
7415    
7416                    return groups;
7417            }
7418    
7419            protected Group doGetCurrentSiteGroup(long groupId) throws PortalException {
7420                    long siteGroupId = getSiteGroupId(groupId);
7421    
7422                    Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7423    
7424                    if (!siteGroup.isLayoutPrototype()) {
7425                            return siteGroup;
7426                    }
7427    
7428                    return null;
7429            }
7430    
7431            protected long doGetPlidFromPortletId(
7432                    long groupId, boolean privateLayout, String portletId) {
7433    
7434                    long scopeGroupId = groupId;
7435    
7436                    try {
7437                            Group group = GroupLocalServiceUtil.getGroup(groupId);
7438    
7439                            if (group.isLayout()) {
7440                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7441                                            group.getClassPK());
7442    
7443                                    groupId = scopeLayout.getGroupId();
7444                            }
7445                    }
7446                    catch (Exception e) {
7447                    }
7448    
7449                    long plid = LayoutConstants.DEFAULT_PLID;
7450    
7451                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7452                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7453    
7454                    for (Layout layout : layouts) {
7455                            LayoutTypePortlet layoutTypePortlet =
7456                                    (LayoutTypePortlet)layout.getLayoutType();
7457    
7458                            if (layoutTypePortlet.hasPortletId(portletId, true)) {
7459                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7460                                            plid = layout.getPlid();
7461    
7462                                            break;
7463                                    }
7464                            }
7465                    }
7466    
7467                    return plid;
7468            }
7469    
7470            protected List<Portlet> filterControlPanelPortlets(
7471                    Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7472    
7473                    List<Portlet> filteredPortlets = new ArrayList<>(portlets);
7474    
7475                    Iterator<Portlet> itr = filteredPortlets.iterator();
7476    
7477                    while (itr.hasNext()) {
7478                            Portlet portlet = itr.next();
7479    
7480                            try {
7481                                    if (!portlet.isActive() || portlet.isInstanceable() ||
7482                                            !PortletPermissionUtil.hasControlPanelAccessPermission(
7483                                                    themeDisplay.getPermissionChecker(),
7484                                                    themeDisplay.getScopeGroupId(), portlet)) {
7485    
7486                                            itr.remove();
7487                                    }
7488                            }
7489                            catch (Exception e) {
7490                                    _log.error(e, e);
7491    
7492                                    itr.remove();
7493                            }
7494                    }
7495    
7496                    return filteredPortlets;
7497            }
7498    
7499            protected Locale getAvailableLocale(long groupId, Locale locale) {
7500                    if (Validator.isNull(locale.getCountry())) {
7501    
7502                            // Locales must contain a country code
7503    
7504                            locale = LanguageUtil.getLocale(locale.getLanguage());
7505                    }
7506    
7507                    if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7508                            return null;
7509                    }
7510    
7511                    return locale;
7512            }
7513    
7514            protected Layout getBrowsableLayout(Layout layout) {
7515                    LayoutType layoutType = layout.getLayoutType();
7516    
7517                    if (layoutType.isBrowsable()) {
7518                            return layout;
7519                    }
7520    
7521                    Layout browsableChildLayout = null;
7522    
7523                    List<Layout> childLayouts = layout.getAllChildren();
7524    
7525                    for (Layout childLayout : childLayouts) {
7526                            LayoutType childLayoutType = childLayout.getLayoutType();
7527    
7528                            if (childLayoutType.isBrowsable()) {
7529                                    browsableChildLayout = childLayout;
7530    
7531                                    break;
7532                            }
7533                    }
7534    
7535                    if (browsableChildLayout != null) {
7536                            return browsableChildLayout;
7537                    }
7538    
7539                    long defaultPlid = LayoutLocalServiceUtil.getDefaultPlid(
7540                            layout.getGroupId(), layout.getPrivateLayout());
7541    
7542                    return LayoutLocalServiceUtil.fetchLayout(defaultPlid);
7543            }
7544    
7545            protected String getCanonicalDomain(
7546                    String virtualHostname, String portalDomain) {
7547    
7548                    if (Validator.isBlank(portalDomain) ||
7549                            StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) ||
7550                            !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7551    
7552                            return virtualHostname;
7553                    }
7554    
7555                    int pos = portalDomain.indexOf(CharPool.COLON);
7556    
7557                    if (pos == -1) {
7558                            return portalDomain;
7559                    }
7560    
7561                    return portalDomain.substring(0, pos);
7562            }
7563    
7564            protected String getContextPath(String contextPath) {
7565                    contextPath = GetterUtil.getString(contextPath);
7566    
7567                    if ((contextPath.length() == 0) ||
7568                            contextPath.equals(StringPool.SLASH)) {
7569    
7570                            contextPath = StringPool.BLANK;
7571                    }
7572                    else if (!contextPath.startsWith(StringPool.SLASH)) {
7573                            contextPath = StringPool.SLASH.concat(contextPath);
7574                    }
7575    
7576                    return contextPath;
7577            }
7578    
7579            protected Group getControlPanelDisplayGroup(
7580                    long companyId, long scopeGroupId, long doAsGroupId, String portletId) {
7581    
7582                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
7583                            companyId, portletId);
7584    
7585                    String portletCategory = portlet.getControlPanelEntryCategory();
7586    
7587                    if (portletCategory.equals(
7588                                    PortletCategoryKeys.CONTROL_PANEL_APPS) ||
7589                            portletCategory.equals(
7590                                    PortletCategoryKeys.CONTROL_PANEL_CONFIGURATION) ||
7591                            portletCategory.equals(
7592                                    PortletCategoryKeys.CONTROL_PANEL_SITES) ||
7593                            portletCategory.equals(
7594                                    PortletCategoryKeys.CONTROL_PANEL_SYSTEM) ||
7595                            portletCategory.equals(
7596                                    PortletCategoryKeys.CONTROL_PANEL_USERS) ||
7597                            portletCategory.equals(
7598                                    PortletCategoryKeys.USER_MY_ACCOUNT)) {
7599    
7600                            return GroupLocalServiceUtil.fetchGroup(
7601                                    companyId, GroupConstants.CONTROL_PANEL);
7602                    }
7603                    else {
7604                            Group group = null;
7605    
7606                            if (doAsGroupId > 0) {
7607                                    group = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
7608                            }
7609    
7610                            if (group == null) {
7611                                    group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
7612                            }
7613    
7614                            return group;
7615                    }
7616            }
7617    
7618            protected long getDoAsUserId(
7619                            HttpServletRequest request, String doAsUserIdString,
7620                            boolean alwaysAllowDoAsUser)
7621                    throws Exception {
7622    
7623                    if (Validator.isNull(doAsUserIdString)) {
7624                            return 0;
7625                    }
7626    
7627                    long doAsUserId = 0;
7628    
7629                    try {
7630                            Company company = getCompany(request);
7631    
7632                            doAsUserId = GetterUtil.getLong(
7633                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7634                    }
7635                    catch (Exception e) {
7636                            if (_log.isWarnEnabled()) {
7637                                    _log.warn(
7638                                            "Unable to impersonate " + doAsUserIdString +
7639                                                    " because the string cannot be decrypted");
7640                            }
7641    
7642                            return 0;
7643                    }
7644    
7645                    if (_log.isDebugEnabled()) {
7646                            if (alwaysAllowDoAsUser) {
7647                                    _log.debug(
7648                                            "doAsUserId path or Struts action is always allowed");
7649                            }
7650                            else {
7651                                    _log.debug(
7652                                            "doAsUserId path is Struts action not always allowed");
7653                            }
7654                    }
7655    
7656                    if (alwaysAllowDoAsUser) {
7657                            request.setAttribute(WebKeys.USER_ID, Long.valueOf(doAsUserId));
7658    
7659                            return doAsUserId;
7660                    }
7661    
7662                    HttpSession session = request.getSession();
7663    
7664                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7665    
7666                    if (realUserIdObj == null) {
7667                            return 0;
7668                    }
7669    
7670                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7671    
7672                    long[] organizationIds = doAsUser.getOrganizationIds();
7673    
7674                    User realUser = UserLocalServiceUtil.getUserById(
7675                            realUserIdObj.longValue());
7676    
7677                    PermissionChecker permissionChecker =
7678                            PermissionCheckerFactoryUtil.create(realUser);
7679    
7680                    if (doAsUser.isDefaultUser() ||
7681                            UserPermissionUtil.contains(
7682                                    permissionChecker, doAsUserId, organizationIds,
7683                                    ActionKeys.IMPERSONATE)) {
7684    
7685                            request.setAttribute(WebKeys.USER_ID, Long.valueOf(doAsUserId));
7686    
7687                            return doAsUserId;
7688                    }
7689    
7690                    _log.error(
7691                            "User " + realUserIdObj + " does not have the permission to " +
7692                                    "impersonate " + doAsUserId);
7693    
7694                    return 0;
7695            }
7696    
7697            protected String getGroupFriendlyURL(
7698                            LayoutSet layoutSet, ThemeDisplay themeDisplay,
7699                            boolean canonicalURL)
7700                    throws PortalException {
7701    
7702                    Group group = layoutSet.getGroup();
7703    
7704                    boolean privateLayoutSet = layoutSet.getPrivateLayout();
7705    
7706                    String portalURL = themeDisplay.getPortalURL();
7707    
7708                    boolean useGroupVirtualHostName = false;
7709    
7710                    if (canonicalURL ||
7711                            !StringUtil.equalsIgnoreCase(
7712                                    themeDisplay.getServerName(), _LOCALHOST)) {
7713    
7714                            useGroupVirtualHostName = true;
7715                    }
7716    
7717                    long refererPlid = themeDisplay.getRefererPlid();
7718    
7719                    if (refererPlid > 0) {
7720                            Layout refererLayout = LayoutLocalServiceUtil.fetchLayout(
7721                                    refererPlid);
7722    
7723                            if ((refererLayout != null) &&
7724                                    ((refererLayout.getGroupId() != group.getGroupId()) ||
7725                                     (refererLayout.isPrivateLayout() != privateLayoutSet))) {
7726    
7727                                    useGroupVirtualHostName = false;
7728                            }
7729                    }
7730    
7731                    if (useGroupVirtualHostName) {
7732                            String virtualHostname = getVirtualHostname(layoutSet);
7733    
7734                            String portalDomain = HttpUtil.getDomain(portalURL);
7735    
7736                            if (Validator.isNotNull(virtualHostname) &&
7737                                    (canonicalURL ||
7738                                     !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7739    
7740                                    virtualHostname = getCanonicalDomain(
7741                                            virtualHostname, portalDomain);
7742    
7743                                    virtualHostname = getPortalURL(
7744                                            virtualHostname, themeDisplay.getServerPort(),
7745                                            themeDisplay.isSecure());
7746    
7747                                    if (canonicalURL || virtualHostname.contains(portalDomain)) {
7748                                            String path = StringPool.BLANK;
7749    
7750                                            if (themeDisplay.isWidget()) {
7751                                                    path = PropsValues.WIDGET_SERVLET_MAPPING;
7752                                            }
7753    
7754                                            if (themeDisplay.isI18n() && !canonicalURL) {
7755                                                    path = themeDisplay.getI18nPath();
7756                                            }
7757    
7758                                            return virtualHostname.concat(_pathContext).concat(path);
7759                                    }
7760                            }
7761                            else {
7762                                    LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7763                                            themeDisplay.getSiteGroupId(), privateLayoutSet);
7764    
7765                                    if (canonicalURL ||
7766                                            ((layoutSet.getLayoutSetId() !=
7767                                                    curLayoutSet.getLayoutSetId()) &&
7768                                             (group.getClassPK() != themeDisplay.getUserId()))) {
7769    
7770                                            if (group.isControlPanel()) {
7771                                                    virtualHostname = themeDisplay.getServerName();
7772    
7773                                                    if (Validator.isNull(virtualHostname) ||
7774                                                            StringUtil.equalsIgnoreCase(
7775                                                                    virtualHostname, _LOCALHOST)) {
7776    
7777                                                            virtualHostname = curLayoutSet.getVirtualHostname();
7778                                                    }
7779                                            }
7780    
7781                                            if (Validator.isNull(virtualHostname) ||
7782                                                    StringUtil.equalsIgnoreCase(
7783                                                            virtualHostname, _LOCALHOST)) {
7784    
7785                                                    Company company = themeDisplay.getCompany();
7786    
7787                                                    virtualHostname = company.getVirtualHostname();
7788                                            }
7789    
7790                                            if (canonicalURL ||
7791                                                    !StringUtil.equalsIgnoreCase(
7792                                                            virtualHostname, _LOCALHOST)) {
7793    
7794                                                    virtualHostname = getCanonicalDomain(
7795                                                            virtualHostname, portalDomain);
7796    
7797                                                    portalURL = getPortalURL(
7798                                                            virtualHostname, themeDisplay.getServerPort(),
7799                                                            themeDisplay.isSecure());
7800                                            }
7801                                    }
7802                            }
7803                    }
7804    
7805                    String friendlyURL = null;
7806    
7807                    if (privateLayoutSet) {
7808                            if (group.isUser()) {
7809                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7810                            }
7811                            else {
7812                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7813                            }
7814                    }
7815                    else {
7816                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7817                    }
7818    
7819                    StringBundler sb = new StringBundler(6);
7820    
7821                    sb.append(portalURL);
7822                    sb.append(_pathContext);
7823    
7824                    if (themeDisplay.isI18n() && !canonicalURL) {
7825                            sb.append(themeDisplay.getI18nPath());
7826                    }
7827    
7828                    if (themeDisplay.isWidget()) {
7829                            sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7830                    }
7831    
7832                    sb.append(friendlyURL);
7833                    sb.append(group.getFriendlyURL());
7834    
7835                    return sb.toString();
7836            }
7837    
7838            protected String[] getGroupPermissions(
7839                    String[] groupPermissions, String className,
7840                    String inputPermissionsShowOptions) {
7841    
7842                    if ((groupPermissions != null) ||
7843                            (inputPermissionsShowOptions != null)) {
7844    
7845                            return groupPermissions;
7846                    }
7847    
7848                    List<String> groupDefaultActions =
7849                            ResourceActionsUtil.getModelResourceGroupDefaultActions(className);
7850    
7851                    return groupDefaultActions.toArray(
7852                            new String[groupDefaultActions.size()]);
7853            }
7854    
7855            protected String[] getGuestPermissions(
7856                    String[] guestPermissions, String className,
7857                    String inputPermissionsShowOptions) {
7858    
7859                    if ((guestPermissions != null) ||
7860                            (inputPermissionsShowOptions != null)) {
7861    
7862                            return guestPermissions;
7863                    }
7864    
7865                    List<String> guestDefaultActions =
7866                            ResourceActionsUtil.getModelResourceGuestDefaultActions(className);
7867    
7868                    return guestDefaultActions.toArray(
7869                            new String[guestDefaultActions.size()]);
7870            }
7871    
7872            protected String getPortletParam(HttpServletRequest request, String name) {
7873                    String portletId = ParamUtil.getString(request, "p_p_id");
7874    
7875                    if (Validator.isNull(portletId)) {
7876                            return StringPool.BLANK;
7877                    }
7878    
7879                    String value = null;
7880    
7881                    int valueCount = 0;
7882    
7883                    String keyName = StringPool.UNDERLINE.concat(name);
7884    
7885                    Map<String, String[]> parameterMap = request.getParameterMap();
7886    
7887                    for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7888                            String parameterName = entry.getKey();
7889    
7890                            int pos = parameterName.indexOf(keyName);
7891    
7892                            if (pos == -1) {
7893                                    continue;
7894                            }
7895    
7896                            valueCount++;
7897    
7898                            // There should never be more than one value
7899    
7900                            if (valueCount > 1) {
7901                                    return StringPool.BLANK;
7902                            }
7903    
7904                            String[] parameterValues = entry.getValue();
7905    
7906                            if (ArrayUtil.isEmpty(parameterValues) ||
7907                                    Validator.isNull(parameterValues[0])) {
7908    
7909                                    continue;
7910                            }
7911    
7912                            // The Struts action must be for the correct portlet
7913    
7914                            String portletId1 = parameterName.substring(1, pos);
7915    
7916                            if (portletId.equals(portletId1)) {
7917                                    value = parameterValues[0];
7918                            }
7919                    }
7920    
7921                    if (value == null) {
7922                            value = StringPool.BLANK;
7923                    }
7924    
7925                    return value;
7926            }
7927    
7928            protected String getServletURL(
7929                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7930                    throws PortalException {
7931    
7932                    Layout layout = themeDisplay.getLayout();
7933    
7934                    StringBundler sb = new StringBundler(9);
7935    
7936                    sb.append(themeDisplay.getPortalURL());
7937    
7938                    if (Validator.isNotNull(_pathContext)) {
7939                            sb.append(_pathContext);
7940                    }
7941    
7942                    if (themeDisplay.isI18n()) {
7943                            sb.append(themeDisplay.getI18nPath());
7944                    }
7945    
7946                    sb.append(servletPath);
7947    
7948                    Group group = layout.getGroup();
7949    
7950                    if (layout.isPrivateLayout()) {
7951                            if (group.isUser()) {
7952                                    sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7953                            }
7954                            else {
7955                                    sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7956                            }
7957                    }
7958                    else {
7959                            sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7960                    }
7961    
7962                    sb.append(group.getFriendlyURL());
7963                    sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7964    
7965                    sb.append(FRIENDLY_URL_SEPARATOR);
7966    
7967                    FriendlyURLMapper friendlyURLMapper =
7968                            portlet.getFriendlyURLMapperInstance();
7969    
7970                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7971                            sb.append(friendlyURLMapper.getMapping());
7972                    }
7973                    else {
7974                            sb.append(portlet.getPortletId());
7975                    }
7976    
7977                    return sb.toString();
7978            }
7979    
7980            protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7981                    throws Exception {
7982    
7983                    String ticketKey = ParamUtil.getString(request, "ticketKey");
7984    
7985                    if (Validator.isNull(ticketKey)) {
7986                            return false;
7987                    }
7988    
7989                    Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7990    
7991                    if ((ticket == null) ||
7992                            (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7993    
7994                            return false;
7995                    }
7996    
7997                    String className = ticket.getClassName();
7998    
7999                    if (!className.equals(User.class.getName())) {
8000                            return false;
8001                    }
8002    
8003                    long doAsUserId = 0;
8004    
8005                    try {
8006                            Company company = getCompany(request);
8007    
8008                            String doAsUserIdString = ParamUtil.getString(
8009                                    request, "doAsUserId");
8010    
8011                            if (Validator.isNotNull(doAsUserIdString)) {
8012                                    doAsUserId = GetterUtil.getLong(
8013                                            Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
8014                            }
8015                    }
8016                    catch (Exception e) {
8017                            return false;
8018                    }
8019    
8020                    if (ticket.getClassPK() != doAsUserId) {
8021                            return false;
8022                    }
8023    
8024                    if (ticket.isExpired()) {
8025                            TicketLocalServiceUtil.deleteTicket(ticket);
8026    
8027                            return false;
8028                    }
8029    
8030                    Date expirationDate = new Date(
8031                            System.currentTimeMillis() +
8032                                    PropsValues.SESSION_TIMEOUT * Time.MINUTE);
8033    
8034                    ticket.setExpirationDate(expirationDate);
8035    
8036                    TicketLocalServiceUtil.updateTicket(ticket);
8037    
8038                    return true;
8039            }
8040    
8041            protected boolean isAlwaysAllowDoAsUser(
8042                    String actionName, String mvcRenderCommandName, String path,
8043                    String strutsAction) {
8044    
8045                    for (AlwaysAllowDoAsUser alwaysAllowDoAsUser : _alwaysAllowDoAsUsers) {
8046                            Collection<String> actionNames =
8047                                    alwaysAllowDoAsUser.getActionNames();
8048    
8049                            if (actionNames.contains(actionName)) {
8050                                    return true;
8051                            }
8052    
8053                            Collection<String> mvcRenderCommandNames =
8054                                    alwaysAllowDoAsUser.getMVCRenderCommandNames();
8055    
8056                            if (mvcRenderCommandNames.contains(mvcRenderCommandName)) {
8057                                    return true;
8058                            }
8059    
8060                            Collection<String> paths = alwaysAllowDoAsUser.getPaths();
8061    
8062                            if (paths.contains(path)) {
8063                                    return true;
8064                            }
8065    
8066                            Collection<String> strutsActions =
8067                                    alwaysAllowDoAsUser.getStrutsActions();
8068    
8069                            if (strutsActions.contains(strutsAction)) {
8070                                    return true;
8071                            }
8072                    }
8073    
8074                    return false;
8075            }
8076    
8077            /**
8078             * @deprecated As of 6.2.0, with no direct replacement
8079             */
8080            @Deprecated
8081            protected boolean isPanelSelectedPortlet(
8082                    ThemeDisplay themeDisplay, String portletId) {
8083    
8084                    Layout layout = themeDisplay.getLayout();
8085    
8086                    String panelSelectedPortlets = layout.getTypeSettingsProperty(
8087                            "panelSelectedPortlets");
8088    
8089                    if (Validator.isNotNull(panelSelectedPortlets)) {
8090                            String[] panelSelectedPortletsArray = StringUtil.split(
8091                                    panelSelectedPortlets);
8092    
8093                            return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
8094                    }
8095    
8096                    return false;
8097            }
8098    
8099            protected boolean isValidPortalDomain(long companyId, String domain) {
8100                    if (_validPortalDomainCheckDisabled) {
8101                            return true;
8102                    }
8103    
8104                    if (!Validator.isHostName(domain)) {
8105                            return false;
8106                    }
8107    
8108                    for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
8109                            if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
8110                                    StringUtil.wildcardMatches(
8111                                            domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
8112                                            CharPool.PERCENT, false)) {
8113    
8114                                    return true;
8115                            }
8116                    }
8117    
8118                    if (StringUtil.equalsIgnoreCase(domain, PropsValues.WEB_SERVER_HOST)) {
8119                            return true;
8120                    }
8121    
8122                    if (isValidVirtualHostname(domain)) {
8123                            return true;
8124                    }
8125    
8126                    if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttp(companyId))) {
8127                            return true;
8128                    }
8129    
8130                    if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttps(companyId))) {
8131                            return true;
8132                    }
8133    
8134                    return false;
8135            }
8136    
8137            protected boolean isValidPortalDomain(String domain) {
8138                    long companyId = CompanyThreadLocal.getCompanyId();
8139    
8140                    return isValidPortalDomain(companyId, domain);
8141            }
8142    
8143            protected boolean isValidVirtualHostname(String virtualHostname) {
8144                    try {
8145                            virtualHostname = StringUtil.toLowerCase(virtualHostname.trim());
8146    
8147                            VirtualHost virtualHost =
8148                                    VirtualHostLocalServiceUtil.fetchVirtualHost(virtualHostname);
8149    
8150                            if (virtualHost != null) {
8151                                    return true;
8152                            }
8153                    }
8154                    catch (Exception e) {
8155                    }
8156    
8157                    return false;
8158            }
8159    
8160            protected void notifyPortalInetSocketAddressEventListeners(
8161                    InetSocketAddress inetSocketAddress, boolean local, boolean secure) {
8162    
8163                    for (PortalInetSocketAddressEventListener
8164                                    portalInetSocketAddressEventListener :
8165                                            _portalInetSocketAddressEventListeners) {
8166    
8167                            if (local) {
8168                                    portalInetSocketAddressEventListener.
8169                                            portalLocalInetSocketAddressConfigured(
8170                                                    inetSocketAddress, secure);
8171                            }
8172                            else {
8173                                    portalInetSocketAddressEventListener.
8174                                            portalServerInetSocketAddressConfigured(
8175                                                    inetSocketAddress, secure);
8176                            }
8177                    }
8178            }
8179    
8180            /**
8181             * @deprecated As of 7.0.0, replaced by {@link
8182             *             #notifyPortalInetSocketAddressEventListeners(
8183             *             InetSocketAddress, boolean, boolean)}
8184             */
8185            @Deprecated
8186            protected void notifyPortalPortEventListeners(int portalPort) {
8187                    for (PortalPortEventListener portalPortEventListener :
8188                                    _portalPortEventListeners) {
8189    
8190                            portalPortEventListener.portalPortConfigured(portalPort);
8191                    }
8192            }
8193    
8194            protected String removeRedirectParameter(String url) {
8195                    String queryString = HttpUtil.getQueryString(url);
8196    
8197                    Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
8198                            queryString);
8199    
8200                    for (String parameter : parameterMap.keySet()) {
8201                            if (parameter.endsWith("redirect")) {
8202                                    url = HttpUtil.removeParameter(url, parameter);
8203                            }
8204                    }
8205    
8206                    return url;
8207            }
8208    
8209            protected void resetThemeDisplayI18n(
8210                    ThemeDisplay themeDisplay, String languageId, String path,
8211                    Locale locale) {
8212    
8213                    themeDisplay.setI18nLanguageId(languageId);
8214                    themeDisplay.setI18nPath(path);
8215                    themeDisplay.setLocale(locale);
8216            }
8217    
8218            protected void setLocale(
8219                    HttpServletRequest request, HttpServletResponse response,
8220                    Locale locale) {
8221    
8222                    HttpSession session = request.getSession();
8223    
8224                    session.setAttribute(Globals.LOCALE_KEY, locale);
8225    
8226                    LanguageUtil.updateCookie(request, response, locale);
8227            }
8228    
8229            protected void setThemeDisplayI18n(
8230                    ThemeDisplay themeDisplay, Locale locale) {
8231    
8232                    String i18nLanguageId = null;
8233                    String i18nPath = null;
8234    
8235                    if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
8236                             (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
8237                             !locale.equals(LocaleUtil.getDefault())) ||
8238                            (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
8239    
8240                            i18nLanguageId = locale.toString();
8241                            i18nPath = buildI18NPath(locale);
8242                    }
8243    
8244                    themeDisplay.setI18nLanguageId(i18nLanguageId);
8245                    themeDisplay.setI18nPath(i18nPath);
8246                    themeDisplay.setLocale(locale);
8247            }
8248    
8249            private static final Log _logWebServerServlet = LogFactoryUtil.getLog(
8250                    WebServerServlet.class);
8251    
8252            private static final String _J_SECURITY_CHECK = "j_security_check";
8253    
8254            private static final String _JOURNAL_ARTICLE_CANONICAL_URL_SEPARATOR =
8255                    "/-/";
8256    
8257            private static final String _LOCALHOST = "localhost";
8258    
8259            private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
8260                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
8261    
8262            private static final String _PRIVATE_USER_SERVLET_MAPPING =
8263                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
8264    
8265            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
8266                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
8267    
8268            private static final Log _log = LogFactoryUtil.getLog(PortalImpl.class);
8269    
8270            private static final Map<Long, String> _cdnHostHttpMap =
8271                    new ConcurrentHashMap<>();
8272            private static final MethodHandler _resetCDNHostsMethodHandler =
8273                    new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
8274            private static final Date _upTime = new Date();
8275    
8276            private final String[] _allSystemGroups;
8277            private final String[] _allSystemOrganizationRoles;
8278            private final String[] _allSystemRoles;
8279            private final String[] _allSystemSiteRoles;
8280            private final List<AlwaysAllowDoAsUser> _alwaysAllowDoAsUsers =
8281                    new ArrayList<>();
8282            private final Pattern _bannedResourceIdPattern = Pattern.compile(
8283                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
8284                    Pattern.CASE_INSENSITIVE);
8285            private final Set<String> _computerAddresses = new HashSet<>();
8286            private final String _computerName;
8287            private String[] _customSqlKeys;
8288            private String[] _customSqlValues;
8289            private final EditDiscussionStrutsAction _editDiscussionStrutsAction =
8290                    new EditDiscussionStrutsAction();
8291            private final GetCommentsStrutsAction _getCommentsStrutsAction =
8292                    new GetCommentsStrutsAction();
8293            private final String _pathContext;
8294            private final String _pathFriendlyURLPrivateGroup;
8295            private final String _pathFriendlyURLPrivateUser;
8296            private final String _pathFriendlyURLPublic;
8297            private final String _pathImage;
8298            private final String _pathMain;
8299            private final String _pathModule;
8300            private final String _pathProxy;
8301            private final Map<String, Long> _plidToPortletIdMap =
8302                    new ConcurrentHashMap<>();
8303            private final Set<PortalInetSocketAddressEventListener>
8304                    _portalInetSocketAddressEventListeners = new CopyOnWriteArraySet<>();
8305            private final AtomicReference<InetSocketAddress>
8306                    _portalLocalInetSocketAddress = new AtomicReference<>();
8307    
8308            /**
8309             * @deprecated As of 7.0.0, replaced by {@link
8310             *             #_portalServerInetSocketAddress}
8311             */
8312            @Deprecated
8313            private final AtomicInteger _portalPort = new AtomicInteger(-1);
8314    
8315            /**
8316             * @deprecated As of 7.0.0, replaced by {@link
8317             *             #_portalInetSocketAddressEventListeners}
8318             */
8319            @Deprecated
8320            private final List<PortalPortEventListener> _portalPortEventListeners =
8321                    new ArrayList<>();
8322    
8323            private final AtomicReference<InetSocketAddress>
8324                    _portalServerInetSocketAddress = new AtomicReference<>();
8325            private final Set<String> _reservedParams;
8326            private final AtomicReference<InetSocketAddress>
8327                    _securePortalLocalInetSocketAddress = new AtomicReference<>();
8328    
8329            /**
8330             * @deprecated As of 7.0.0, replaced by {@link
8331             *             #_securePortalServerInetSocketAddress}
8332             */
8333            @Deprecated
8334            private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
8335    
8336            private final AtomicReference<InetSocketAddress>
8337                    _securePortalServerInetSocketAddress = new AtomicReference<>();
8338            private final String _servletContextName;
8339            private final String[] _sortedSystemGroups;
8340            private final String[] _sortedSystemOrganizationRoles;
8341            private final String[] _sortedSystemRoles;
8342            private final String[] _sortedSystemSiteRoles;
8343            private final boolean _validPortalDomainCheckDisabled;
8344    
8345            private class AlwaysAllowDoAsUserServiceTrackerCustomizer
8346                    implements ServiceTrackerCustomizer
8347                            <AlwaysAllowDoAsUser, AlwaysAllowDoAsUser> {
8348    
8349                    @Override
8350                    public AlwaysAllowDoAsUser addingService(
8351                            ServiceReference<AlwaysAllowDoAsUser> serviceReference) {
8352    
8353                            Registry registry = RegistryUtil.getRegistry();
8354    
8355                            AlwaysAllowDoAsUser alwaysAllowDoAsUser = registry.getService(
8356                                    serviceReference);
8357    
8358                            if (_log.isDebugEnabled()) {
8359                                    _log.debug(
8360                                            "Add alway sallow do as user " +
8361                                                    ClassUtil.getClassName(alwaysAllowDoAsUser));
8362                            }
8363    
8364                            _alwaysAllowDoAsUsers.add(alwaysAllowDoAsUser);
8365    
8366                            if (_log.isDebugEnabled()) {
8367                                    _log.debug(
8368                                            "There are " + _alwaysAllowDoAsUsers.size() +
8369                                                    " alway sallow do as user instances");
8370                            }
8371    
8372                            return alwaysAllowDoAsUser;
8373                    }
8374    
8375                    @Override
8376                    public void modifiedService(
8377                            ServiceReference<AlwaysAllowDoAsUser> serviceReference,
8378                            AlwaysAllowDoAsUser alwaysAllowDoAsUser) {
8379                    }
8380    
8381                    @Override
8382                    public void removedService(
8383                            ServiceReference<AlwaysAllowDoAsUser> serviceReference,
8384                            AlwaysAllowDoAsUser alwaysAllowDoAsUser) {
8385    
8386                            Registry registry = RegistryUtil.getRegistry();
8387    
8388                            registry.ungetService(serviceReference);
8389    
8390                            if (_log.isDebugEnabled()) {
8391                                    _log.debug(
8392                                            "Delete alway sallow do as user " +
8393                                                    ClassUtil.getClassName(alwaysAllowDoAsUser));
8394                            }
8395    
8396                            _alwaysAllowDoAsUsers.remove(alwaysAllowDoAsUser);
8397    
8398                            if (_log.isDebugEnabled()) {
8399                                    _log.debug(
8400                                            "There are " + _alwaysAllowDoAsUsers.size() +
8401                                                    " alway sallow do as user instances");
8402                            }
8403                    }
8404    
8405            }
8406    
8407            private class PortalInetSocketAddressEventListenerServiceTrackerCustomizer
8408                    implements ServiceTrackerCustomizer
8409                            <PortalInetSocketAddressEventListener,
8410                                    PortalInetSocketAddressEventListener> {
8411    
8412                    @Override
8413                    public PortalInetSocketAddressEventListener addingService(
8414                            ServiceReference<PortalInetSocketAddressEventListener>
8415                                    serviceReference) {
8416    
8417                            Registry registry = RegistryUtil.getRegistry();
8418    
8419                            PortalInetSocketAddressEventListener
8420                                    portalInetSocketAddressEventListener = registry.getService(
8421                                            serviceReference);
8422    
8423                            addPortalInetSocketAddressEventListener(
8424                                    portalInetSocketAddressEventListener);
8425    
8426                            return portalInetSocketAddressEventListener;
8427                    }
8428    
8429                    @Override
8430                    public void modifiedService(
8431                            ServiceReference<PortalInetSocketAddressEventListener>
8432                                    serviceReference,
8433                            PortalInetSocketAddressEventListener
8434                                    portalInetSocketAddressEventListener) {
8435                    }
8436    
8437                    @Override
8438                    public void removedService(
8439                            ServiceReference<PortalInetSocketAddressEventListener>
8440                                    serviceReference,
8441                            PortalInetSocketAddressEventListener
8442                                    portalInetSocketAddressEventListener) {
8443    
8444                            Registry registry = RegistryUtil.getRegistry();
8445    
8446                            registry.ungetService(serviceReference);
8447    
8448                            removePortalInetSocketAddressEventListener(
8449                                    portalInetSocketAddressEventListener);
8450                    }
8451    
8452            }
8453    
8454            private static final Map<Long, String> _cdnHostHttpsMap =
8455                    new ConcurrentHashMap<>();
8456    
8457    }