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