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