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