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