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