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