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