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