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