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