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