001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.util;
016    
017    import com.liferay.portal.NoSuchCompanyException;
018    import com.liferay.portal.NoSuchImageException;
019    import com.liferay.portal.NoSuchLayoutException;
020    import com.liferay.portal.NoSuchResourceException;
021    import com.liferay.portal.NoSuchUserException;
022    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
023    import com.liferay.portal.kernel.dao.db.DB;
024    import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
025    import com.liferay.portal.kernel.exception.PortalException;
026    import com.liferay.portal.kernel.exception.SystemException;
027    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
028    import com.liferay.portal.kernel.language.LanguageUtil;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
032    import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
033    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
034    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
035    import com.liferay.portal.kernel.portlet.LiferayWindowState;
036    import com.liferay.portal.kernel.portlet.PortletBag;
037    import com.liferay.portal.kernel.portlet.PortletBagPool;
038    import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
039    import com.liferay.portal.kernel.servlet.HttpHeaders;
040    import com.liferay.portal.kernel.servlet.HttpMethods;
041    import com.liferay.portal.kernel.servlet.PipingServletResponse;
042    import com.liferay.portal.kernel.servlet.ServletContextUtil;
043    import com.liferay.portal.kernel.servlet.SessionErrors;
044    import com.liferay.portal.kernel.servlet.StringServletResponse;
045    import com.liferay.portal.kernel.servlet.WebDirDetector;
046    import com.liferay.portal.kernel.upload.UploadPortletRequest;
047    import com.liferay.portal.kernel.upload.UploadServletRequest;
048    import com.liferay.portal.kernel.util.ArrayUtil;
049    import com.liferay.portal.kernel.util.Base64;
050    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
051    import com.liferay.portal.kernel.util.CharPool;
052    import com.liferay.portal.kernel.util.ClassUtil;
053    import com.liferay.portal.kernel.util.ContentTypes;
054    import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
055    import com.liferay.portal.kernel.util.GetterUtil;
056    import com.liferay.portal.kernel.util.HtmlUtil;
057    import com.liferay.portal.kernel.util.Http;
058    import com.liferay.portal.kernel.util.HttpUtil;
059    import com.liferay.portal.kernel.util.InheritableMap;
060    import com.liferay.portal.kernel.util.JavaConstants;
061    import com.liferay.portal.kernel.util.KeyValuePair;
062    import com.liferay.portal.kernel.util.LocaleUtil;
063    import com.liferay.portal.kernel.util.ParamUtil;
064    import com.liferay.portal.kernel.util.PropsKeys;
065    import com.liferay.portal.kernel.util.ReleaseInfo;
066    import com.liferay.portal.kernel.util.SetUtil;
067    import com.liferay.portal.kernel.util.StringBundler;
068    import com.liferay.portal.kernel.util.StringComparator;
069    import com.liferay.portal.kernel.util.StringPool;
070    import com.liferay.portal.kernel.util.StringUtil;
071    import com.liferay.portal.kernel.util.UnicodeProperties;
072    import com.liferay.portal.kernel.util.Validator;
073    import com.liferay.portal.kernel.xml.QName;
074    import com.liferay.portal.model.BaseModel;
075    import com.liferay.portal.model.ClassName;
076    import com.liferay.portal.model.ColorScheme;
077    import com.liferay.portal.model.Company;
078    import com.liferay.portal.model.CompanyConstants;
079    import com.liferay.portal.model.Group;
080    import com.liferay.portal.model.GroupConstants;
081    import com.liferay.portal.model.Layout;
082    import com.liferay.portal.model.LayoutConstants;
083    import com.liferay.portal.model.LayoutSet;
084    import com.liferay.portal.model.LayoutTypePortlet;
085    import com.liferay.portal.model.Organization;
086    import com.liferay.portal.model.Portlet;
087    import com.liferay.portal.model.PublicRenderParameter;
088    import com.liferay.portal.model.Resource;
089    import com.liferay.portal.model.ResourceCode;
090    import com.liferay.portal.model.ResourceConstants;
091    import com.liferay.portal.model.ResourcePermission;
092    import com.liferay.portal.model.Role;
093    import com.liferay.portal.model.RoleConstants;
094    import com.liferay.portal.model.Theme;
095    import com.liferay.portal.model.User;
096    import com.liferay.portal.model.UserGroup;
097    import com.liferay.portal.plugin.PluginPackageUtil;
098    import com.liferay.portal.security.auth.AuthTokenUtil;
099    import com.liferay.portal.security.auth.PrincipalException;
100    import com.liferay.portal.security.permission.ActionKeys;
101    import com.liferay.portal.security.permission.PermissionChecker;
102    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
103    import com.liferay.portal.security.permission.ResourceActionsUtil;
104    import com.liferay.portal.service.ClassNameLocalServiceUtil;
105    import com.liferay.portal.service.CompanyLocalServiceUtil;
106    import com.liferay.portal.service.GroupLocalServiceUtil;
107    import com.liferay.portal.service.LayoutLocalServiceUtil;
108    import com.liferay.portal.service.PortletLocalServiceUtil;
109    import com.liferay.portal.service.ResourceCodeLocalServiceUtil;
110    import com.liferay.portal.service.ResourceLocalServiceUtil;
111    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
112    import com.liferay.portal.service.UserLocalServiceUtil;
113    import com.liferay.portal.service.UserServiceUtil;
114    import com.liferay.portal.service.permission.GroupPermissionUtil;
115    import com.liferay.portal.service.permission.LayoutPermissionUtil;
116    import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
117    import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
118    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
119    import com.liferay.portal.service.permission.PortletPermissionUtil;
120    import com.liferay.portal.service.permission.UserPermissionUtil;
121    import com.liferay.portal.servlet.ImageServlet;
122    import com.liferay.portal.servlet.filters.i18n.I18nFilter;
123    import com.liferay.portal.struts.StrutsUtil;
124    import com.liferay.portal.theme.ThemeDisplay;
125    import com.liferay.portal.upload.UploadPortletRequestImpl;
126    import com.liferay.portal.upload.UploadServletRequestImpl;
127    import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
128    import com.liferay.portlet.ActionResponseImpl;
129    import com.liferay.portlet.ControlPanelEntry;
130    import com.liferay.portlet.DefaultControlPanelEntryFactory;
131    import com.liferay.portlet.PortletConfigFactoryUtil;
132    import com.liferay.portlet.PortletConfigImpl;
133    import com.liferay.portlet.PortletContextImpl;
134    import com.liferay.portlet.PortletPreferencesFactoryUtil;
135    import com.liferay.portlet.PortletPreferencesImpl;
136    import com.liferay.portlet.PortletPreferencesWrapper;
137    import com.liferay.portlet.PortletQNameUtil;
138    import com.liferay.portlet.PortletRequestImpl;
139    import com.liferay.portlet.PortletResponseImpl;
140    import com.liferay.portlet.PortletURLImpl;
141    import com.liferay.portlet.RenderRequestImpl;
142    import com.liferay.portlet.RenderResponseImpl;
143    import com.liferay.portlet.UserAttributes;
144    import com.liferay.portlet.admin.util.OmniadminUtil;
145    import com.liferay.portlet.blogs.model.BlogsEntry;
146    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
147    import com.liferay.portlet.calendar.model.CalEvent;
148    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
149    import com.liferay.portlet.expando.action.EditExpandoAction;
150    import com.liferay.portlet.expando.model.ExpandoBridge;
151    import com.liferay.portlet.imagegallery.model.IGImage;
152    import com.liferay.portlet.messageboards.model.MBMessage;
153    import com.liferay.portlet.social.model.SocialEquityActionMapping;
154    import com.liferay.portlet.social.util.FacebookUtil;
155    import com.liferay.portlet.wiki.model.WikiPage;
156    import com.liferay.util.Encryptor;
157    import com.liferay.util.JS;
158    import com.liferay.util.PwdGenerator;
159    import com.liferay.util.UniqueList;
160    import com.liferay.util.servlet.DynamicServletRequest;
161    
162    import java.io.File;
163    import java.io.IOException;
164    import java.io.Serializable;
165    
166    import java.lang.reflect.Method;
167    
168    import java.net.InetAddress;
169    import java.net.UnknownHostException;
170    
171    import java.util.ArrayList;
172    import java.util.Arrays;
173    import java.util.Calendar;
174    import java.util.Date;
175    import java.util.Enumeration;
176    import java.util.HashMap;
177    import java.util.HashSet;
178    import java.util.Iterator;
179    import java.util.List;
180    import java.util.Locale;
181    import java.util.Map;
182    import java.util.Properties;
183    import java.util.ResourceBundle;
184    import java.util.Set;
185    import java.util.TimeZone;
186    import java.util.TreeSet;
187    import java.util.concurrent.ConcurrentHashMap;
188    import java.util.concurrent.locks.Lock;
189    import java.util.concurrent.locks.ReentrantLock;
190    import java.util.regex.Matcher;
191    import java.util.regex.Pattern;
192    
193    import javax.portlet.ActionRequest;
194    import javax.portlet.ActionResponse;
195    import javax.portlet.PortletConfig;
196    import javax.portlet.PortletMode;
197    import javax.portlet.PortletPreferences;
198    import javax.portlet.PortletRequest;
199    import javax.portlet.PortletResponse;
200    import javax.portlet.PortletURL;
201    import javax.portlet.PreferencesValidator;
202    import javax.portlet.RenderRequest;
203    import javax.portlet.RenderResponse;
204    import javax.portlet.ValidatorException;
205    import javax.portlet.WindowState;
206    
207    import javax.servlet.RequestDispatcher;
208    import javax.servlet.ServletContext;
209    import javax.servlet.ServletException;
210    import javax.servlet.http.HttpServletRequest;
211    import javax.servlet.http.HttpServletRequestWrapper;
212    import javax.servlet.http.HttpServletResponse;
213    import javax.servlet.http.HttpSession;
214    import javax.servlet.jsp.PageContext;
215    
216    import org.apache.struts.Globals;
217    
218    /**
219     * @author Brian Wing Shun Chan
220     * @author Brian Myunghun Kim
221     * @author Jorge Ferrer
222     * @author Raymond Augé
223     * @author Eduardo Lundgren
224     * @author Wesley Gong
225     */
226    public class PortalImpl implements Portal {
227    
228            public PortalImpl() {
229    
230                    // Computer name
231    
232                    _computerName = System.getProperty("env.COMPUTERNAME");
233    
234                    if (Validator.isNull(_computerName)) {
235                            _computerName = System.getProperty("env.HOST");
236                    }
237    
238                    if (Validator.isNull(_computerName)) {
239                            _computerName = System.getProperty("env.HOSTNAME");
240                    }
241    
242                    if (Validator.isNull(_computerName)) {
243                            try {
244                                    _computerName = InetAddress.getLocalHost().getHostName();
245                            }
246                            catch (UnknownHostException uhe) {
247                            }
248                    }
249    
250                    try {
251                            _computerAddress = InetAddress.getByName(
252                                    _computerName).getHostAddress();
253                    }
254                    catch (UnknownHostException uhe) {
255                    }
256    
257                    if (Validator.isNull(_computerAddress)) {
258                            try {
259                                    _computerAddress = InetAddress.getLocalHost().getHostAddress();
260                            }
261                            catch (UnknownHostException uhe) {
262                            }
263                    }
264    
265                    // Global lib directory
266    
267                    _globalLibDir = ClassUtil.getParentPath(
268                            ReleaseInfo.class.getClassLoader(), ReleaseInfo.class.getName());
269    
270                    int pos = _globalLibDir.lastIndexOf(".jar!");
271    
272                    pos = _globalLibDir.lastIndexOf(StringPool.SLASH, pos);
273    
274                    _globalLibDir = _globalLibDir.substring(0, pos + 1);
275    
276                    if (_log.isInfoEnabled()) {
277                            _log.info("Global lib directory " + _globalLibDir);
278                    }
279    
280                    // Portal lib directory
281    
282                    ClassLoader classLoader = getClass().getClassLoader();
283    
284                    _portalLibDir = WebDirDetector.getLibDir(classLoader);
285    
286                    String portalLibDir = System.getProperty("liferay.lib.portal.dir");
287    
288                    if (portalLibDir != null) {
289                            if (!portalLibDir.endsWith(StringPool.SLASH)) {
290                                    portalLibDir += StringPool.SLASH;
291                            }
292    
293                            _portalLibDir = portalLibDir;
294                    }
295    
296                    if (_log.isInfoEnabled()) {
297                            _log.info("Portal lib directory " + _portalLibDir);
298                    }
299    
300                    _portalWebDir = WebDirDetector.getRootDir(_portalLibDir);
301    
302                    if (_log.isDebugEnabled()) {
303                            _log.debug("Portal web directory " + _portalWebDir);
304                    }
305    
306                    // CDN host
307    
308                    _cdnHostHttp = PropsValues.CDN_HOST_HTTP;
309    
310                    if (_cdnHostHttp.startsWith("${")) {
311                            _cdnHostHttp = StringPool.BLANK;
312                    }
313    
314                    _cdnHostHttps = PropsValues.CDN_HOST_HTTPS;
315    
316                    if (_cdnHostHttps.startsWith("${")) {
317                            _cdnHostHttps = StringPool.BLANK;
318                    }
319    
320                    // Paths
321    
322                    _pathContext = PropsUtil.get(PropsKeys.PORTAL_CTX);
323    
324                    if (_pathContext.equals(StringPool.SLASH)) {
325                            _pathContext = StringPool.BLANK;
326                    }
327    
328                    _pathFriendlyURLPrivateGroup =
329                            _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
330                    _pathFriendlyURLPrivateUser =
331                            _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
332                    _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
333                    _pathImage = _pathContext + PATH_IMAGE;
334                    _pathMain = _pathContext + PATH_MAIN;
335    
336                    // Groups
337    
338                    String customSystemGroups[] =
339                            PropsUtil.getArray(PropsKeys.SYSTEM_GROUPS);
340    
341                    if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
342                            _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
343                    }
344                    else {
345                            _allSystemGroups = ArrayUtil.append(
346                                    GroupConstants.SYSTEM_GROUPS, customSystemGroups);
347                    }
348    
349                    _sortedSystemGroups = new String[_allSystemGroups.length];
350    
351                    System.arraycopy(
352                            _allSystemGroups, 0, _sortedSystemGroups, 0,
353                            _allSystemGroups.length);
354    
355                    Arrays.sort(_sortedSystemGroups, new StringComparator());
356    
357                    // Regular roles
358    
359                    String customSystemRoles[] = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
360    
361                    if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
362                            _allSystemRoles = RoleConstants.SYSTEM_ROLES;
363                    }
364                    else {
365                            _allSystemRoles = ArrayUtil.append(
366                                    RoleConstants.SYSTEM_ROLES, customSystemRoles);
367                    }
368    
369                    _sortedSystemRoles = new String[_allSystemRoles.length];
370    
371                    System.arraycopy(
372                            _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
373    
374                    Arrays.sort(_sortedSystemRoles, new StringComparator());
375    
376                    // Community roles
377    
378                    String customSystemCommunityRoles[] =
379                            PropsUtil.getArray(PropsKeys.SYSTEM_COMMUNITY_ROLES);
380    
381                    if ((customSystemCommunityRoles == null) ||
382                            (customSystemCommunityRoles.length == 0)) {
383    
384                            _allSystemCommunityRoles = RoleConstants.SYSTEM_COMMUNITY_ROLES;
385                    }
386                    else {
387                            _allSystemCommunityRoles = ArrayUtil.append(
388                                    RoleConstants.SYSTEM_COMMUNITY_ROLES,
389                                    customSystemCommunityRoles);
390                    }
391    
392                    _sortedSystemCommunityRoles =
393                            new String[_allSystemCommunityRoles.length];
394    
395                    System.arraycopy(
396                            _allSystemCommunityRoles, 0, _sortedSystemCommunityRoles, 0,
397                                    _allSystemCommunityRoles.length);
398    
399                    Arrays.sort(_sortedSystemCommunityRoles, new StringComparator());
400    
401                    // Organization Roles
402    
403                    String customSystemOrganizationRoles[] =
404                            PropsUtil.getArray(PropsKeys.SYSTEM_ORGANIZATION_ROLES);
405    
406                    if ((customSystemOrganizationRoles == null) ||
407                            (customSystemOrganizationRoles.length == 0)) {
408    
409                            _allSystemOrganizationRoles =
410                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES;
411                    }
412                    else {
413                            _allSystemOrganizationRoles = ArrayUtil.append(
414                                    RoleConstants.SYSTEM_ORGANIZATION_ROLES,
415                                    customSystemOrganizationRoles);
416                    }
417    
418                    _sortedSystemOrganizationRoles =
419                            new String[_allSystemOrganizationRoles.length];
420    
421                    System.arraycopy(
422                            _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
423                                    _allSystemOrganizationRoles.length);
424    
425                    Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
426    
427                    // Portlet add default resource check white list
428    
429                    _portletAddDefaultResourceCheckWhitelist = SetUtil.fromArray(
430                            PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST);
431                    _portletAddDefaultResourceCheckWhitelistActions = SetUtil.fromArray(
432                            PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS);
433    
434                    // Reserved parameter names
435    
436                    _reservedParams = new HashSet<String>();
437    
438                    _reservedParams.add("p_auth");
439                    _reservedParams.add("p_auth_secret");
440                    _reservedParams.add("p_l_id");
441                    _reservedParams.add("p_l_reset");
442                    _reservedParams.add("p_p_auth");
443                    _reservedParams.add("p_p_id");
444                    _reservedParams.add("p_p_lifecycle");
445                    _reservedParams.add("p_p_url_type");
446                    _reservedParams.add("p_p_state");
447                    _reservedParams.add("p_p_mode");
448                    _reservedParams.add("p_p_resource_id");
449                    _reservedParams.add("p_p_cacheability");
450                    _reservedParams.add("p_p_width");
451                    _reservedParams.add("p_p_col_id");
452                    _reservedParams.add("p_p_col_pos");
453                    _reservedParams.add("p_p_col_count");
454                    _reservedParams.add("p_p_static");
455                    _reservedParams.add("p_p_isolated");
456                    _reservedParams.add("saveLastPath");
457                    _reservedParams.add("scroll");
458            }
459    
460            /**
461             * Adds the description for a page. This appends to the existing page
462             * description.
463             */
464            public void addPageDescription(
465                    String description, HttpServletRequest request) {
466    
467                    String requestDescription = (String)request.getAttribute(
468                            WebKeys.PAGE_DESCRIPTION);
469    
470                    if (requestDescription != null) {
471                            description = requestDescription + StringPool.SPACE + description;
472                    }
473    
474                    request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
475            }
476    
477            /**
478             * Adds the keywords for a page. This appends to the existing page keywords.
479             */
480            public void addPageKeywords(String keywords, HttpServletRequest request) {
481                    List<String> requestKeywords = (List<String>)request.getAttribute(
482                            WebKeys.PAGE_KEYWORDS);
483    
484                    if (requestKeywords == null) {
485                            requestKeywords = new UniqueList<String>();
486                    }
487    
488                    String[] keywordsArray = StringUtil.split(keywords);
489    
490                    for (String keyword : keywordsArray) {
491                            if (!requestKeywords.contains(keyword.toLowerCase())) {
492                                    requestKeywords.add(keyword.toLowerCase());
493                            }
494                    }
495    
496                    request.setAttribute(WebKeys.PAGE_KEYWORDS, requestKeywords);
497            }
498    
499            /**
500             * Adds the subtitle for a page. This appends to the existing page subtitle.
501             */
502            public void addPageSubtitle(String subtitle, HttpServletRequest request) {
503                    String requestSubtitle = (String)request.getAttribute(
504                            WebKeys.PAGE_SUBTITLE);
505    
506                    if (requestSubtitle != null) {
507                            subtitle = requestSubtitle + StringPool.SPACE + subtitle;
508                    }
509    
510                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
511            }
512    
513            /**
514             * Adds the whole title for a page. This appends to the existing page whole
515             * title.
516             */
517            public void addPageTitle(String title, HttpServletRequest request) {
518                    String requestTitle = (String)request.getAttribute(WebKeys.PAGE_TITLE);
519    
520                    if (requestTitle != null) {
521                            title = requestTitle + StringPool.SPACE + title;
522                    }
523    
524                    request.setAttribute(WebKeys.PAGE_TITLE, title);
525            }
526    
527            public void addPortalPortEventListener(
528                    PortalPortEventListener portalPortEventListener) {
529    
530                    if (!_portalPortEventListeners.contains(portalPortEventListener)) {
531                            _portalPortEventListeners.add(portalPortEventListener);
532                    }
533            }
534    
535            public void addPortletBreadcrumbEntry(
536                    HttpServletRequest request, String title, String url) {
537    
538                    List<KeyValuePair> portletBreadcrumbList =
539                            (List<KeyValuePair>)request.getAttribute(
540                                    WebKeys.PORTLET_BREADCRUMB_MAP);
541    
542                    if (portletBreadcrumbList == null) {
543                            portletBreadcrumbList = new ArrayList<KeyValuePair>();
544    
545                            request.setAttribute(
546                                    WebKeys.PORTLET_BREADCRUMB_MAP, portletBreadcrumbList);
547                    }
548    
549                    portletBreadcrumbList.add(new KeyValuePair(title, url));
550            }
551    
552            public void addPortletDefaultResource(
553                            HttpServletRequest request, Portlet portlet)
554                    throws PortalException, SystemException {
555    
556                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
557                            WebKeys.THEME_DISPLAY);
558    
559                    Layout layout = themeDisplay.getLayout();
560    
561                    addDefaultResource(themeDisplay, layout, portlet, true);
562                    addDefaultResource(themeDisplay, layout, portlet, false);
563            }
564    
565            public void clearRequestParameters(RenderRequest renderRequest) {
566    
567                    // Clear the render parameters if they were set during processAction
568    
569                    ThemeDisplay themeDisplay = (ThemeDisplay)renderRequest.getAttribute(
570                            WebKeys.THEME_DISPLAY);
571    
572                    if (themeDisplay.isLifecycleAction()) {
573                            ((RenderRequestImpl)renderRequest).getRenderParameters().clear();
574                    }
575            }
576    
577            public void copyRequestParameters(
578                    ActionRequest actionRequest, ActionResponse actionResponse) {
579    
580                    try {
581                            ActionResponseImpl actionResponseImpl =
582                                    (ActionResponseImpl)actionResponse;
583    
584                            Map<String, String[]> renderParameters =
585                                    actionResponseImpl.getRenderParameterMap();
586    
587                            actionResponse.setRenderParameter("p_p_lifecycle", "1");
588    
589                            Enumeration<String> enu = actionRequest.getParameterNames();
590    
591                            while (enu.hasMoreElements()) {
592                                    String param = enu.nextElement();
593                                    String[] values = actionRequest.getParameterValues(param);
594    
595                                    if (renderParameters.get(
596                                                    actionResponseImpl.getNamespace() + param) == null) {
597    
598                                            actionResponse.setRenderParameter(param, values);
599                                    }
600                            }
601                    }
602                    catch (IllegalStateException ise) {
603    
604                            // This should only happen if the developer called
605                            // sendRedirect of javax.portlet.ActionResponse
606    
607                    }
608            }
609    
610            public String escapeRedirect(String url) {
611                    if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
612                            return url;
613                    }
614    
615                    try {
616                            String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
617    
618                            String domain = StringUtil.split(
619                                    HttpUtil.getDomain(url), StringPool.COLON)[0];
620    
621                            if (securityMode.equals("domain")) {
622                                    String[] allowedDomains =
623                                            PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
624    
625                                    if ((allowedDomains.length > 0) &&
626                                            !ArrayUtil.contains(allowedDomains, domain)) {
627    
628                                            if (_log.isDebugEnabled()) {
629                                                    _log.debug("Redirect URL " + url + " is not allowed");
630                                            }
631    
632                                            url = null;
633                                    }
634                            }
635                            else if (securityMode.equals("ip")) {
636                                    String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
637    
638                                    InetAddress inetAddress = InetAddress.getByName(domain);
639    
640                                    if ((allowedIps.length > 0) &&
641                                            !ArrayUtil.contains(
642                                                    allowedIps, inetAddress.getHostAddress())) {
643    
644                                            String serverIp = getComputerAddress();
645    
646                                            if (!serverIp.equals(inetAddress.getHostAddress()) ||
647                                                    !ArrayUtil.contains(allowedIps, "SERVER_IP")) {
648    
649                                                    if (_log.isDebugEnabled()) {
650                                                            _log.debug(
651                                                                    "Redirect URL " + url + " is not allowed");
652                                                    }
653    
654                                                    url = null;
655                                            }
656                                    }
657                            }
658                    }
659                    catch (UnknownHostException uhe) {
660                            if (_log.isDebugEnabled()) {
661                                    _log.debug("Unable to determine IP for redirect URL " + url);
662                            }
663    
664                            url = null;
665                    }
666    
667                    return url;
668            }
669    
670            public String generateRandomKey(HttpServletRequest request, String input) {
671                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
672                            WebKeys.THEME_DISPLAY);
673    
674                    if (themeDisplay.isLifecycleResource() ||
675                            themeDisplay.isStateExclusive()) {
676    
677                            return PwdGenerator.getPassword(PwdGenerator.KEY3, 4);
678                    }
679                    else {
680                            return DeterminateKeyGenerator.generate(input);
681                    }
682            }
683    
684            public BaseModel<?> getBaseModel(Resource resource)
685                    throws PortalException, SystemException {
686    
687                    ResourceCode resourceCode =
688                            ResourceCodeLocalServiceUtil.getResourceCode(resource.getCodeId());
689    
690                    String modelName = resourceCode.getName();
691                    String primKey = resource.getPrimKey();
692    
693                    return getBaseModel(modelName, primKey);
694            }
695    
696            public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
697                    throws PortalException, SystemException {
698    
699                    String modelName = resourcePermission.getName();
700                    String primKey = resourcePermission.getPrimKey();
701    
702                    return getBaseModel(modelName, primKey);
703            }
704    
705            public BaseModel<?> getBaseModel(String modelName, String primKey)
706                    throws PortalException, SystemException {
707    
708                    if (!modelName.contains(".model.")) {
709                            return null;
710                    }
711    
712                    String[] parts = StringUtil.split(modelName, StringPool.PERIOD);
713    
714                    if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
715                            return null;
716                    }
717    
718                    parts[parts.length - 2] = "service";
719    
720                    String serviceName =
721                            StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
722                    String methodName = "get" + parts[parts.length - 1];
723    
724                    Method method = null;
725    
726                    try {
727                            Class<?> serviceUtil = Class.forName(serviceName);
728    
729                            if (Validator.isNumber(primKey)) {
730                                    method = serviceUtil.getMethod(
731                                            methodName, new Class[] {Long.TYPE});
732    
733                                    return (BaseModel<?>)method.invoke(null, new Long(primKey));
734                            }
735                            else {
736                                    method = serviceUtil.getMethod(
737                                            methodName, new Class[] {String.class});
738    
739                                    return (BaseModel<?>)method.invoke(null, primKey);
740                            }
741                    }
742                    catch (Exception e) {
743                            Throwable cause = e.getCause();
744    
745                            if (cause instanceof PortalException) {
746                                    throw (PortalException)cause;
747                            }
748                            else if (cause instanceof SystemException) {
749                                    throw (SystemException)cause;
750                            }
751                            else {
752                                    throw new SystemException(cause);
753                            }
754                    }
755            }
756    
757            public long getBasicAuthUserId(HttpServletRequest request)
758                    throws PortalException, SystemException {
759    
760                    long companyId = PortalInstances.getCompanyId(request);
761    
762                    return getBasicAuthUserId(request, companyId);
763            }
764    
765            public long getBasicAuthUserId(HttpServletRequest request, long companyId)
766                    throws PortalException, SystemException {
767    
768                    long userId = 0;
769    
770                    String authorizationHeader = request.getHeader(
771                            HttpHeaders.AUTHORIZATION);
772    
773                    if (Validator.isNull(authorizationHeader)) {
774                            return userId;
775                    }
776    
777                    String[] authorizationArray = authorizationHeader.split("\\s+");
778    
779                    String authorization = authorizationArray[0];
780                    String credentials = new String(Base64.decode(authorizationArray[1]));
781    
782                    if (!authorization.equalsIgnoreCase(HttpServletRequest.BASIC_AUTH)) {
783                            return userId;
784                    }
785    
786                    String[] loginAndPassword = StringUtil.split(
787                            credentials, StringPool.COLON);
788    
789                    String login = loginAndPassword[0].trim();
790    
791                    String password = null;
792    
793                    if (loginAndPassword.length > 1) {
794                            password = loginAndPassword[1].trim();
795                    }
796    
797                    // Strip @uid and @sn for backwards compatibility
798    
799                    if (login.endsWith("@uid")) {
800                            int pos = login.indexOf("@uid");
801    
802                            login = login.substring(0, pos);
803                    }
804                    else if (login.endsWith("@sn")) {
805                            int pos = login.indexOf("@sn");
806    
807                            login = login.substring(0, pos);
808                    }
809    
810                    // Try every authentication type
811    
812                    userId = UserLocalServiceUtil.authenticateForBasic(
813                            companyId, CompanyConstants.AUTH_TYPE_EA, login, password);
814    
815                    if (userId > 0) {
816                            return userId;
817                    }
818    
819                    userId = UserLocalServiceUtil.authenticateForBasic(
820                            companyId, CompanyConstants.AUTH_TYPE_SN, login, password);
821    
822                    if (userId > 0) {
823                            return userId;
824                    }
825    
826                    userId = UserLocalServiceUtil.authenticateForBasic(
827                            companyId, CompanyConstants.AUTH_TYPE_ID, login, password);
828    
829                    return userId;
830            }
831    
832            /**
833             * @deprecated {@link #getCDNHost(boolean)}
834             */
835            public String getCDNHost() {
836                    return getCDNHostHttp();
837            }
838    
839            public String getCDNHost(boolean secure) {
840                    if (secure) {
841                            return getCDNHostHttps();
842                    }
843                    else {
844                            return getCDNHostHttp();
845                    }
846            }
847    
848            public String getCDNHostHttp() {
849                    return _cdnHostHttp;
850            }
851    
852            public String getCDNHostHttps() {
853                    return _cdnHostHttps;
854            }
855    
856            public String getClassName(long classNameId) {
857                    try {
858                            ClassName className = ClassNameLocalServiceUtil.getClassName(
859                                    classNameId);
860    
861                            return className.getValue();
862                    }
863                    catch (Exception e) {
864                            throw new RuntimeException(
865                                    "Unable to get class name from id " + classNameId);
866                    }
867            }
868    
869            public long getClassNameId(Class<?> classObj) {
870                    return ClassNameLocalServiceUtil.getClassNameId(classObj);
871            }
872    
873            public long getClassNameId(String value) {
874                    return ClassNameLocalServiceUtil.getClassNameId(value);
875            }
876    
877            public String getClassNamePortletId(String className) {
878                    String portletId = StringPool.BLANK;
879    
880                    if (className.startsWith("com.liferay.portlet.blogs")) {
881                            portletId = PortletKeys.BLOGS;
882                    }
883                    else if (className.startsWith("com.liferay.portlet.bookmarks")) {
884                            portletId = PortletKeys.BOOKMARKS;
885                    }
886                    else if (className.startsWith("com.liferay.portlet.calendar")) {
887                            portletId = PortletKeys.CALENDAR;
888                    }
889                    else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
890                            portletId = PortletKeys.DOCUMENT_LIBRARY;
891                    }
892                    else if (className.startsWith("com.liferay.portlet.imagegallery")) {
893                            portletId = PortletKeys.IMAGE_GALLERY;
894                    }
895                    else if (className.startsWith("com.liferay.portlet.journal")) {
896                            portletId = PortletKeys.JOURNAL;
897                    }
898                    else if (className.startsWith("com.liferay.portlet.messageboards")) {
899                            portletId = PortletKeys.MESSAGE_BOARDS;
900                    }
901                    else if (className.startsWith("com.liferay.portlet.wiki")) {
902                            portletId = PortletKeys.WIKI;
903                    }
904    
905                    return portletId;
906            }
907    
908            public String getCommunityLoginURL(ThemeDisplay themeDisplay)
909                    throws PortalException, SystemException {
910    
911                    if (Validator.isNull(PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
912                            return null;
913                    }
914    
915                    for (Layout layout : themeDisplay.getLayouts()) {
916                            if (layout.getFriendlyURL().equals(
917                                            PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
918    
919                                    if (themeDisplay.getLayout() != null) {
920                                            String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
921                                                    themeDisplay.getLayout().getLayoutSet(), themeDisplay);
922    
923                                            return layoutSetFriendlyURL +
924                                                    PropsValues.AUTH_LOGIN_COMMUNITY_URL;
925                                    }
926    
927                                    break;
928                            }
929                    }
930    
931                    return null;
932            }
933    
934            public String[] getCommunityPermissions(HttpServletRequest request) {
935                    return request.getParameterValues("communityPermissions");
936            }
937    
938            public String[] getCommunityPermissions(PortletRequest portletRequest) {
939                    return portletRequest.getParameterValues("communityPermissions");
940            }
941    
942            public Company getCompany(HttpServletRequest request)
943                    throws PortalException, SystemException {
944    
945                    long companyId = getCompanyId(request);
946    
947                    if (companyId <= 0) {
948                            return null;
949                    }
950    
951                    Company company = (Company)request.getAttribute(WebKeys.COMPANY);
952    
953                    if (company == null) {
954    
955                            // LEP-5994
956    
957                            try {
958                                    company = CompanyLocalServiceUtil.getCompanyById(companyId);
959                            }
960                            catch (NoSuchCompanyException nsce) {
961                                    company = CompanyLocalServiceUtil.getCompanyById(
962                                            PortalInstances.getDefaultCompanyId());
963                            }
964    
965                            request.setAttribute(WebKeys.COMPANY, company);
966                    }
967    
968                    return company;
969            }
970    
971            public Company getCompany(PortletRequest portletRequest)
972                    throws PortalException, SystemException {
973    
974                    return getCompany(getHttpServletRequest(portletRequest));
975            }
976    
977            public long getCompanyId(HttpServletRequest request) {
978                    return PortalInstances.getCompanyId(request);
979            }
980    
981            public long getCompanyId(PortletRequest portletRequest) {
982                    return getCompanyId(getHttpServletRequest(portletRequest));
983            }
984    
985            public long[] getCompanyIds() {
986                    return PortalInstances.getCompanyIds();
987            }
988    
989            public String getComputerAddress() {
990                    return _computerAddress;
991            }
992    
993            public String getComputerName() {
994                    return _computerName;
995            }
996    
997            public String getControlPanelCategory(
998                            String portletId, ThemeDisplay themeDisplay)
999                    throws SystemException {
1000    
1001                    for (String category : PortletCategoryKeys.ALL) {
1002                            List<Portlet> portlets = getControlPanelPortlets(
1003                                    category, themeDisplay);
1004    
1005                            for (Portlet portlet : portlets) {
1006                                    if (portlet.getPortletId().equals(portletId)) {
1007                                            return category;
1008                                    }
1009                            }
1010                    }
1011    
1012                    return StringPool.BLANK;
1013            }
1014    
1015            public String getControlPanelFullURL(
1016                            long scopeGroupId, String ppid, Map<String, String[]> params)
1017                    throws PortalException, SystemException {
1018    
1019                    StringBundler sb = new StringBundler(6);
1020    
1021                    Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1022    
1023                    Company company = CompanyLocalServiceUtil.getCompany(
1024                            group.getCompanyId());
1025    
1026                    sb.append(
1027                            getPortalURL(company.getVirtualHost(), getPortalPort(), false));
1028                    sb.append(PortalUtil.getPathFriendlyURLPrivateGroup());
1029                    sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1030                    sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1031    
1032                    if (params != null) {
1033                            params = new HashMap<String, String[]>(params);
1034                    }
1035                    else {
1036                            params = new HashMap<String, String[]>();
1037                    }
1038    
1039                    params.put("p_p_id", new String[] {ppid});
1040                    params.put("p_p_lifecycle", new String[] {"0"});
1041                    params.put(
1042                            "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1043                    params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1044    
1045                    sb.append(HttpUtil.parameterMapToString(params, true));
1046    
1047                    return sb.toString();
1048            }
1049    
1050            public List<Portlet> getControlPanelPortlets(
1051                            String category, ThemeDisplay themeDisplay)
1052                    throws SystemException {
1053    
1054                    Set<Portlet> portletsSet = new TreeSet<Portlet>(
1055                            new PortletControlPanelWeightComparator());
1056    
1057                    List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1058                            themeDisplay.getCompanyId());
1059    
1060                    for (Portlet portlet : portletsList) {
1061                            if (category.equals(portlet.getControlPanelEntryCategory())) {
1062                                    portletsSet.add(portlet);
1063                            }
1064                    }
1065    
1066                    return filterControlPanelPortlets(portletsSet, category, themeDisplay);
1067            }
1068    
1069            public String getCurrentCompleteURL(HttpServletRequest request) {
1070                    String currentCompleteURL = (String)request.getAttribute(
1071                            WebKeys.CURRENT_COMPLETE_URL);
1072    
1073                    if (currentCompleteURL == null) {
1074                            currentCompleteURL = HttpUtil.getCompleteURL(request);
1075    
1076                            request.setAttribute(
1077                                    WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1078                    }
1079    
1080                    return currentCompleteURL;
1081            }
1082    
1083            public String getCurrentURL(HttpServletRequest request) {
1084                    String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1085    
1086                    if (currentURL == null) {
1087                            currentURL = ParamUtil.getString(request, "currentURL");
1088    
1089                            if (Validator.isNull(currentURL)) {
1090                                    currentURL = HttpUtil.getCompleteURL(request);
1091    
1092                                    if ((Validator.isNotNull(currentURL)) &&
1093                                            (currentURL.indexOf(_J_SECURITY_CHECK) == -1)) {
1094    
1095                                            currentURL = currentURL.substring(
1096                                                    currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1097                                                            Http.PROTOCOL_DELIMITER.length());
1098    
1099                                            currentURL = currentURL.substring(
1100                                                    currentURL.indexOf(StringPool.SLASH));
1101                                    }
1102    
1103                                    if (Validator.isNotNull(currentURL) &&
1104                                            FacebookUtil.isFacebook(currentURL)) {
1105    
1106                                            String[] facebookData = FacebookUtil.getFacebookData(
1107                                                    request);
1108    
1109                                            currentURL =
1110                                                    FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1111                                                            facebookData[2];
1112                                    }
1113                            }
1114    
1115                            if (Validator.isNull(currentURL)) {
1116                                    currentURL = getPathMain();
1117                            }
1118    
1119                            request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1120                    }
1121    
1122                    return currentURL;
1123            }
1124    
1125            public String getCurrentURL(PortletRequest portletRequest) {
1126                    return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1127            }
1128    
1129            public String getCustomSQLFunctionIsNotNull() {
1130                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1131            }
1132    
1133            public String getCustomSQLFunctionIsNull() {
1134                    return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1135            }
1136    
1137            public Date getDate(int month, int day, int year) {
1138                    try {
1139                            return getDate(month, day, year, null);
1140                    }
1141                    catch (PortalException pe) {
1142                            throw new RuntimeException();
1143                    }
1144            }
1145    
1146            public Date getDate(
1147                            int month, int day, int year, int hour, int min, PortalException pe)
1148                    throws PortalException {
1149    
1150                    return getDate(month, day, year, hour, min, null, pe);
1151            }
1152    
1153            public Date getDate(
1154                            int month, int day, int year, int hour, int min, TimeZone timeZone,
1155                            PortalException pe)
1156                    throws PortalException {
1157    
1158                    if (!Validator.isGregorianDate(month, day, year)) {
1159                            if (pe != null) {
1160                                    throw pe;
1161                            }
1162                            else {
1163                                    return null;
1164                            }
1165                    }
1166                    else {
1167                            Calendar cal = null;
1168    
1169                            if (timeZone == null) {
1170                                    cal = CalendarFactoryUtil.getCalendar();
1171                            }
1172                            else {
1173                                    cal = CalendarFactoryUtil.getCalendar(timeZone);
1174                            }
1175    
1176                            if ((hour == -1) || (min == -1)) {
1177                                    cal.set(year, month, day, 0, 0, 0);
1178                            }
1179                            else {
1180                                    cal.set(year, month, day, hour, min, 0);
1181                            }
1182    
1183                            cal.set(Calendar.MILLISECOND, 0);
1184    
1185                            Date date = cal.getTime();
1186    
1187                            /*if (timeZone != null &&
1188                                    cal.before(CalendarFactoryUtil.getCalendar(timeZone))) {
1189    
1190                                    throw pe;
1191                            }*/
1192    
1193                            return date;
1194                    }
1195            }
1196    
1197            public Date getDate(int month, int day, int year, PortalException pe)
1198                    throws PortalException {
1199    
1200                    return getDate(month, day, year, null, pe);
1201            }
1202    
1203            public Date getDate(
1204                            int month, int day, int year, TimeZone timeZone, PortalException pe)
1205                    throws PortalException {
1206    
1207                    return getDate(month, day, year, -1, -1, timeZone, pe);
1208            }
1209    
1210            public long getDefaultCompanyId() {
1211                    return PortalInstances.getDefaultCompanyId();
1212            }
1213    
1214            public Map<String, Serializable> getExpandoBridgeAttributes(
1215                            ExpandoBridge expandoBridge, PortletRequest portletRequest)
1216                    throws PortalException, SystemException {
1217    
1218                    Map<String, Serializable> attributes =
1219                            new HashMap<String, Serializable>();
1220    
1221                    List<String> names = new ArrayList<String>();
1222    
1223                    Enumeration<String> enu = portletRequest.getParameterNames();
1224    
1225                    while (enu.hasMoreElements()) {
1226                            String param = enu.nextElement();
1227    
1228                            if (param.indexOf("ExpandoAttributeName--") != -1) {
1229                                    String name = ParamUtil.getString(portletRequest, param);
1230    
1231                                    names.add(name);
1232                            }
1233                    }
1234    
1235                    for (String name : names) {
1236                            int type = expandoBridge.getAttributeType(name);
1237    
1238                            Serializable value = EditExpandoAction.getValue(
1239                                    portletRequest, "ExpandoAttribute--" + name + "--", type);
1240    
1241                            attributes.put(name, value);
1242                    }
1243    
1244                    return attributes;
1245            }
1246    
1247            public String getFirstPageLayoutTypes(PageContext pageContext) {
1248                    StringBundler sb = new StringBundler();
1249    
1250                    for (String type : PropsValues.LAYOUT_TYPES) {
1251                            if (isLayoutFirstPageable(type)) {
1252                                    sb.append(
1253                                            LanguageUtil.get(pageContext, "layout.types." + type));
1254                                    sb.append(StringPool.COMMA);
1255                                    sb.append(StringPool.SPACE);
1256                            }
1257                    }
1258    
1259                    if (sb.index() >= 2) {
1260                            sb.setIndex(sb.index() - 2);
1261                    }
1262    
1263                    return sb.toString();
1264            }
1265    
1266            public String getGlobalLibDir() {
1267                    return _globalLibDir;
1268            }
1269    
1270            public String getGoogleGadgetURL(
1271                            Portlet portlet, ThemeDisplay themeDisplay)
1272                    throws PortalException, SystemException {
1273    
1274                    return _getServletURL(
1275                            portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
1276            }
1277    
1278            public String[] getGuestPermissions(HttpServletRequest request) {
1279                    return request.getParameterValues("guestPermissions");
1280            }
1281    
1282            public String[] getGuestPermissions(PortletRequest portletRequest) {
1283                    return portletRequest.getParameterValues("guestPermissions");
1284            }
1285    
1286            public String getHomeURL(HttpServletRequest request)
1287                    throws PortalException, SystemException {
1288    
1289                    String portalURL = getPortalURL(request);
1290    
1291                    Company company = getCompany(request);
1292    
1293                    String homeURL = company.getHomeURL();
1294    
1295                    if (Validator.isNull(homeURL)) {
1296                            homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
1297                    }
1298    
1299                    return portalURL + _pathContext + homeURL;
1300            }
1301    
1302            public String getHost(HttpServletRequest request) {
1303                    request = getOriginalServletRequest(request);
1304    
1305                    String host = request.getHeader("Host");
1306    
1307                    if (host != null) {
1308                            host = host.trim().toLowerCase();
1309    
1310                            int pos = host.indexOf(':');
1311    
1312                            if (pos >= 0) {
1313                                    host = host.substring(0, pos);
1314                            }
1315                    }
1316                    else {
1317                            host = null;
1318                    }
1319    
1320                    return host;
1321            }
1322    
1323            public String getHost(PortletRequest portletRequest) {
1324                    return getHost(getHttpServletRequest(portletRequest));
1325            }
1326    
1327            public HttpServletRequest getHttpServletRequest(
1328                    PortletRequest portletRequest) {
1329    
1330                    PortletRequestImpl portletRequestImpl =
1331                            PortletRequestImpl.getPortletRequestImpl(portletRequest);
1332    
1333                    return portletRequestImpl.getHttpServletRequest();
1334            }
1335    
1336            public HttpServletResponse getHttpServletResponse(
1337                    PortletResponse portletResponse) {
1338    
1339                    PortletResponseImpl portletResponseImpl =
1340                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
1341    
1342                    return portletResponseImpl.getHttpServletResponse();
1343            }
1344    
1345            public String getJsSafePortletId(String portletId) {
1346                    return JS.getSafeName(portletId);
1347            }
1348    
1349            public String getLayoutActualURL(Layout layout) {
1350                    return getLayoutActualURL(layout, getPathMain());
1351            }
1352    
1353            public String getLayoutActualURL(Layout layout, String mainPath) {
1354                    Map<String, String> variables = new HashMap<String, String>();
1355    
1356                    variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
1357                    variables.put("liferay:mainPath", mainPath);
1358                    variables.put("liferay:plid", String.valueOf(layout.getPlid()));
1359    
1360                    UnicodeProperties typeSettingsProperties =
1361                            layout.getLayoutType().getTypeSettingsProperties();
1362    
1363                    Iterator<Map.Entry<String, String>> itr =
1364                            typeSettingsProperties.entrySet().iterator();
1365    
1366                    while (itr.hasNext()) {
1367                            Map.Entry<String, String> entry = itr.next();
1368    
1369                            String key = entry.getKey();
1370                            String value = entry.getValue();
1371    
1372                            variables.put(key, value);
1373                    }
1374    
1375                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
1376    
1377                    return layoutSettings.getURL(variables);
1378            }
1379    
1380            public String getLayoutActualURL(
1381                            long groupId, boolean privateLayout, String mainPath,
1382                            String friendlyURL)
1383                    throws PortalException, SystemException {
1384    
1385                    return getLayoutActualURL(
1386                            groupId, privateLayout, mainPath, friendlyURL, null, null);
1387            }
1388    
1389            public String getLayoutActualURL(
1390                            long groupId, boolean privateLayout, String mainPath,
1391                            String friendlyURL, Map<String, String[]> params,
1392                            Map<String, Object> requestContext)
1393                    throws PortalException, SystemException {
1394    
1395                    Layout layout = null;
1396                    String queryString = StringPool.BLANK;
1397    
1398                    if (Validator.isNull(friendlyURL)) {
1399                            List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
1400                                    groupId, privateLayout,
1401                                    LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
1402    
1403                            if (layouts.size() > 0) {
1404                                    layout = layouts.get(0);
1405                            }
1406                            else {
1407                                    throw new NoSuchLayoutException(
1408                                            "{groupId=" + groupId + ",privateLayout=" + privateLayout +
1409                                                    "} does not have any layouts");
1410                            }
1411                    }
1412                    else {
1413                            Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
1414                                    groupId, privateLayout, friendlyURL, params, requestContext);
1415    
1416                            layout = (Layout)friendlyURLMapper[0];
1417                            queryString = (String)friendlyURLMapper[1];
1418                    }
1419    
1420                    String layoutActualURL = getLayoutActualURL(layout, mainPath);
1421    
1422                    if (Validator.isNotNull(queryString)) {
1423                            layoutActualURL = layoutActualURL + queryString;
1424                    }
1425                    else if (params.isEmpty()) {
1426                            UnicodeProperties typeSettingsProperties =
1427                                    layout.getLayoutType().getTypeSettingsProperties();
1428    
1429                            queryString = typeSettingsProperties.getProperty("query-string");
1430    
1431                            if (Validator.isNotNull(queryString) &&
1432                                    layoutActualURL.contains(StringPool.QUESTION)) {
1433    
1434                                    layoutActualURL =
1435                                            layoutActualURL + StringPool.AMPERSAND + queryString;
1436                            }
1437                    }
1438    
1439                    return layoutActualURL;
1440            }
1441    
1442            public String getLayoutEditPage(Layout layout) {
1443                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
1444                            layout.getType());
1445    
1446                    return layoutSettings.getEditPage();
1447            }
1448    
1449            public String getLayoutEditPage(String type) {
1450                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
1451    
1452                    return layoutSettings.getEditPage();
1453            }
1454    
1455            public String getLayoutFriendlyURL(
1456                            Layout layout, ThemeDisplay themeDisplay)
1457                    throws PortalException, SystemException {
1458    
1459                    if (!isLayoutFriendliable(layout)) {
1460                            return null;
1461                    }
1462    
1463                    String layoutFriendlyURL = layout.getFriendlyURL();
1464    
1465                    LayoutSet layoutSet = layout.getLayoutSet();
1466    
1467                    long curLayoutSetId =
1468                            themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1469    
1470                    String portalURL = StringPool.BLANK;
1471    
1472                    if (!themeDisplay.getServerName().equals(_LOCALHOST)) {
1473                            String virtualHost = layoutSet.getVirtualHost();
1474    
1475                            if (Validator.isNull(virtualHost) &&
1476                                    Validator.isNotNull(
1477                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME) &&
1478                                    !layoutSet.isPrivateLayout()) {
1479    
1480                                    try {
1481                                            Group group = GroupLocalServiceUtil.getGroup(
1482                                                    themeDisplay.getCompanyId(),
1483                                                    PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME);
1484    
1485                                            if (layoutSet.getGroupId() == group.getGroupId()) {
1486                                                    Company company = themeDisplay.getCompany();
1487    
1488                                                    virtualHost = company.getVirtualHost();
1489                                            }
1490                                    }
1491                                    catch (Exception e) {
1492                                            _log.error(e, e);
1493                                    }
1494                            }
1495    
1496                            if (Validator.isNotNull(virtualHost) &&
1497                                    !virtualHost.equalsIgnoreCase(_LOCALHOST)) {
1498    
1499                                    virtualHost = getPortalURL(
1500                                            virtualHost, themeDisplay.getServerPort(),
1501                                            themeDisplay.isSecure());
1502    
1503                                    String portalDomain = HttpUtil.getDomain(
1504                                            themeDisplay.getPortalURL());
1505    
1506                                    if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1507                                            (virtualHost.indexOf(portalDomain) != -1)) {
1508    
1509                                            if (themeDisplay.isWidget()) {
1510                                                    layoutFriendlyURL =
1511                                                            PropsValues.WIDGET_SERVLET_MAPPING +
1512                                                                    layoutFriendlyURL;
1513                                            }
1514    
1515                                            if (themeDisplay.isI18n()) {
1516                                                    layoutFriendlyURL =
1517                                                            themeDisplay.getI18nPath() + layoutFriendlyURL;
1518                                            }
1519    
1520                                            return virtualHost + _pathContext + layoutFriendlyURL;
1521                                    }
1522                            }
1523                            else {
1524                                    if ((layoutSet.getLayoutSetId() != curLayoutSetId) &&
1525                                            (layout.getGroup().getClassPK() !=
1526                                                    themeDisplay.getUserId())) {
1527    
1528                                            virtualHost = themeDisplay.getCompany().getVirtualHost();
1529    
1530                                            if (!virtualHost.equalsIgnoreCase(_LOCALHOST)) {
1531                                                    portalURL = getPortalURL(
1532                                                            virtualHost, themeDisplay.getServerPort(),
1533                                                            themeDisplay.isSecure());
1534                                            }
1535                                    }
1536                            }
1537                    }
1538    
1539                    Group group = layout.getGroup();
1540    
1541                    String friendlyURL = null;
1542    
1543                    if (layout.isPrivateLayout()) {
1544                            if (group.isUser()) {
1545                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1546                            }
1547                            else {
1548                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1549                            }
1550                    }
1551                    else {
1552                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1553                    }
1554    
1555                    if (themeDisplay.isWidget()) {
1556                            friendlyURL = PropsValues.WIDGET_SERVLET_MAPPING + friendlyURL;
1557                    }
1558    
1559                    if (themeDisplay.isI18n()) {
1560                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
1561                    }
1562    
1563                    return portalURL + _pathContext + friendlyURL + group.getFriendlyURL() +
1564                            layoutFriendlyURL;
1565            }
1566    
1567            public String getLayoutFriendlyURL(
1568                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1569                    throws PortalException, SystemException {
1570    
1571                    String i18nLanguageId = themeDisplay.getI18nLanguageId();
1572                    String i18nPath = themeDisplay.getI18nPath();
1573    
1574                    try {
1575                            String tempI18nLanguageId = null;
1576    
1577                            if ((I18nFilter.getLanguageIds().contains(locale.toString())) &&
1578                                    ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
1579                                     (!locale.equals(LocaleUtil.getDefault()))) ||
1580                                    (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
1581    
1582                                    tempI18nLanguageId = locale.toString();
1583                            }
1584    
1585                            String tempI18nPath = null;
1586    
1587                            if (Validator.isNotNull(tempI18nLanguageId)) {
1588                                    tempI18nPath = StringPool.SLASH + tempI18nLanguageId;
1589    
1590                                    if (!LanguageUtil.isDuplicateLanguageCode(
1591                                                    locale.getLanguage())) {
1592    
1593                                            tempI18nPath = StringPool.SLASH + locale.getLanguage();
1594                                    }
1595                                    else {
1596                                            Locale priorityLocale = LanguageUtil.getLocale(
1597                                                    locale.getLanguage());
1598    
1599                                            if (locale.equals(priorityLocale)) {
1600                                                    tempI18nPath = StringPool.SLASH + locale.getLanguage();
1601                                            }
1602                                    }
1603                            }
1604    
1605                            themeDisplay.setI18nLanguageId(tempI18nLanguageId);
1606                            themeDisplay.setI18nPath(tempI18nPath);
1607    
1608                            return getLayoutFriendlyURL(layout, themeDisplay);
1609                    }
1610                    finally {
1611                            themeDisplay.setI18nLanguageId(i18nLanguageId);
1612                            themeDisplay.setI18nPath(i18nPath);
1613                    }
1614            }
1615    
1616            public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
1617                    throws PortalException, SystemException {
1618    
1619                    return getLayoutFullURL(layout, themeDisplay, true);
1620            }
1621    
1622            public String getLayoutFullURL(
1623                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1624                    throws PortalException, SystemException {
1625    
1626                    String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
1627                    String portalURL = themeDisplay.getPortalURL();
1628    
1629                    if (StringUtil.startsWith(layoutURL, portalURL)) {
1630                            return layoutURL;
1631                    }
1632                    else {
1633                            return portalURL + layoutURL;
1634                    }
1635            }
1636    
1637            public String getLayoutFullURL(long groupId, String portletId)
1638                    throws PortalException, SystemException {
1639    
1640                    long plid = getPlidFromPortletId(groupId, portletId);
1641    
1642                    if (plid == LayoutConstants.DEFAULT_PLID) {
1643                            return null;
1644                    }
1645    
1646                    StringBundler sb = new StringBundler(4);
1647    
1648                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1649    
1650                    Company company = CompanyLocalServiceUtil.getCompany(
1651                            layout.getCompanyId());
1652    
1653                    Group group = GroupLocalServiceUtil.getGroup(groupId);
1654    
1655                    String portalURL = getPortalURL(
1656                            company.getVirtualHost(), getPortalPort(), false);
1657    
1658                    sb.append(portalURL);
1659    
1660                    if (layout.isPrivateLayout()) {
1661                            if (group.isUser()) {
1662                                    sb.append(PortalUtil.getPathFriendlyURLPrivateUser());
1663                            }
1664                            else {
1665                                    sb.append(PortalUtil.getPathFriendlyURLPrivateGroup());
1666                            }
1667                    }
1668                    else {
1669                            sb.append(PortalUtil.getPathFriendlyURLPublic());
1670                    }
1671    
1672                    sb.append(group.getFriendlyURL());
1673                    sb.append(layout.getFriendlyURL());
1674    
1675                    return sb.toString();
1676            }
1677    
1678            public String getLayoutFullURL(ThemeDisplay themeDisplay)
1679                    throws PortalException, SystemException {
1680    
1681                    return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
1682            }
1683    
1684            public String getLayoutSetFriendlyURL(
1685                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1686                    throws PortalException, SystemException {
1687    
1688                    String virtualHost = layoutSet.getVirtualHost();
1689    
1690                    if (Validator.isNull(virtualHost) &&
1691                            Validator.isNotNull(
1692                                    PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME) &&
1693                            !layoutSet.isPrivateLayout()) {
1694    
1695                            try {
1696                                    Group group = GroupLocalServiceUtil.getGroup(
1697                                            themeDisplay.getCompanyId(),
1698                                            PropsValues.VIRTUAL_HOSTS_DEFAULT_COMMUNITY_NAME);
1699    
1700                                    if (layoutSet.getGroupId() == group.getGroupId()) {
1701                                            Company company = themeDisplay.getCompany();
1702    
1703                                            virtualHost = company.getVirtualHost();
1704                                    }
1705                            }
1706                            catch (Exception e) {
1707                                    _log.error(e, e);
1708                            }
1709                    }
1710    
1711                    if (Validator.isNotNull(virtualHost)) {
1712                            String portalURL = getPortalURL(
1713                                    virtualHost, themeDisplay.getServerPort(),
1714                                    themeDisplay.isSecure());
1715    
1716                            // Use the layout set's virtual host setting only if the layout set
1717                            // is already used for the current request
1718    
1719                            long curLayoutSetId =
1720                                    themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1721    
1722                            if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1723                                    (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1724    
1725                                    String layoutSetFriendlyURL = StringPool.BLANK;
1726    
1727                                    if (themeDisplay.isI18n()) {
1728                                            layoutSetFriendlyURL = themeDisplay.getI18nPath();
1729                                    }
1730    
1731                                    return portalURL + _pathContext + layoutSetFriendlyURL;
1732                            }
1733                    }
1734    
1735                    Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1736    
1737                    String friendlyURL = null;
1738    
1739                    if (layoutSet.isPrivateLayout()) {
1740                            if (group.isUser()) {
1741                                    friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1742                            }
1743                            else {
1744                                    friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1745                            }
1746                    }
1747                    else {
1748                            friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1749                    }
1750    
1751                    if (themeDisplay.isI18n()) {
1752                            friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
1753                    }
1754    
1755                    return _pathContext + friendlyURL + group.getFriendlyURL();
1756            }
1757    
1758            public String getLayoutTarget(Layout layout) {
1759                    UnicodeProperties typeSettingsProps =
1760                            layout.getTypeSettingsProperties();
1761    
1762                    String target = typeSettingsProps.getProperty("target");
1763    
1764                    if (Validator.isNull(target)) {
1765                            target = StringPool.BLANK;
1766                    }
1767                    else {
1768                            target = "target=\"" + target + "\"";
1769                    }
1770    
1771                    return target;
1772            }
1773    
1774            public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
1775                    throws PortalException, SystemException {
1776    
1777                    return getLayoutURL(layout, themeDisplay, true);
1778            }
1779    
1780            public String getLayoutURL(
1781                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1782                    throws PortalException, SystemException {
1783    
1784                    if (layout == null) {
1785                            return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
1786                    }
1787    
1788                    if (!layout.isTypeURL()) {
1789                            String layoutFriendlyURL = getLayoutFriendlyURL(
1790                                    layout, themeDisplay);
1791    
1792                            if (Validator.isNotNull(layoutFriendlyURL)) {
1793                                    if (doAsUser) {
1794                                            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
1795                                                    layoutFriendlyURL = HttpUtil.addParameter(
1796                                                            layoutFriendlyURL, "doAsUserId",
1797                                                            themeDisplay.getDoAsUserId());
1798                                            }
1799    
1800                                            if (Validator.isNotNull(
1801                                                            themeDisplay.getDoAsUserLanguageId())) {
1802    
1803                                                    layoutFriendlyURL = HttpUtil.addParameter(
1804                                                            layoutFriendlyURL, "doAsUserLanguageId",
1805                                                            themeDisplay.getDoAsUserLanguageId());
1806                                            }
1807                                    }
1808    
1809                                    if (layout.isTypeControlPanel()) {
1810                                            if (themeDisplay.getRefererPlid() !=
1811                                                            LayoutConstants.DEFAULT_PLID) {
1812    
1813                                                    layoutFriendlyURL = HttpUtil.addParameter(
1814                                                            layoutFriendlyURL, "refererPlid",
1815                                                            themeDisplay.getRefererPlid());
1816                                            }
1817    
1818                                            if (themeDisplay.getDoAsGroupId() > 0) {
1819                                                    layoutFriendlyURL = HttpUtil.addParameter(
1820                                                            layoutFriendlyURL, "doAsGroupId",
1821                                                            themeDisplay.getDoAsGroupId());
1822                                            }
1823                                    }
1824    
1825                                    return layoutFriendlyURL;
1826                            }
1827                    }
1828    
1829                    String layoutURL = getLayoutActualURL(layout);
1830    
1831                    if (doAsUser) {
1832                            if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
1833                                    layoutURL = HttpUtil.addParameter(
1834                                            layoutURL, "doAsUserId", themeDisplay.getDoAsUserId());
1835                            }
1836    
1837                            if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
1838                                    layoutURL = HttpUtil.addParameter(
1839                                            layoutURL, "doAsUserLanguageId",
1840                                            themeDisplay.getDoAsUserLanguageId());
1841                            }
1842                    }
1843    
1844                    if (layout.isTypeControlPanel()) {
1845                            if (themeDisplay.getDoAsGroupId() > 0) {
1846                                    layoutURL = HttpUtil.addParameter(
1847                                            layoutURL, "doAsGroupId", themeDisplay.getDoAsGroupId());
1848                            }
1849    
1850                            if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
1851                                    layoutURL = HttpUtil.addParameter(
1852                                            layoutURL, "refererPlid", themeDisplay.getRefererPlid());
1853                            }
1854                    }
1855    
1856                    return layoutURL;
1857            }
1858    
1859            public String getLayoutURL(ThemeDisplay themeDisplay)
1860                    throws PortalException, SystemException {
1861    
1862                    return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
1863            }
1864    
1865            public String getLayoutViewPage(Layout layout) {
1866                    LayoutSettings layoutSettings = LayoutSettings.getInstance(
1867                            layout.getType());
1868    
1869                    return layoutSettings.getViewPage();
1870            }
1871    
1872            public String getLayoutViewPage(String type) {
1873                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
1874    
1875                    return layoutSettings.getViewPage();
1876            }
1877    
1878            public LiferayPortletResponse getLiferayPortletResponse(
1879                    PortletResponse portletResponse) {
1880    
1881                    PortletResponseImpl portletResponseImpl =
1882                            PortletResponseImpl.getPortletResponseImpl(portletResponse);
1883    
1884                    return portletResponseImpl;
1885            }
1886    
1887            public Locale getLocale(HttpServletRequest request) {
1888                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1889                            WebKeys.THEME_DISPLAY);
1890    
1891                    if (themeDisplay != null) {
1892                            return themeDisplay.getLocale();
1893                    }
1894                    else {
1895                            HttpSession session = request.getSession();
1896    
1897                            return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1898                    }
1899            }
1900    
1901            public Locale getLocale(RenderRequest renderRequest) {
1902                    return getLocale(getHttpServletRequest(renderRequest));
1903            }
1904    
1905            public String getNetvibesURL(
1906                            Portlet portlet, ThemeDisplay themeDisplay)
1907                    throws PortalException, SystemException {
1908    
1909                    return _getServletURL(
1910                            portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
1911            }
1912    
1913            public HttpServletRequest getOriginalServletRequest(
1914                    HttpServletRequest request) {
1915    
1916                    HttpServletRequest originalRequest = request;
1917    
1918                    while (originalRequest.getClass().getName().startsWith(
1919                                            "com.liferay.")) {
1920    
1921                            // Get original request so that portlets inside portlets render
1922                            // properly
1923    
1924                            originalRequest = (HttpServletRequest)
1925                                    ((HttpServletRequestWrapper)originalRequest).getRequest();
1926                    }
1927    
1928                    return originalRequest;
1929            }
1930    
1931            public long getParentGroupId(long groupId)
1932                    throws PortalException, SystemException {
1933    
1934                    if (groupId <= 0) {
1935                            return 0;
1936                    }
1937    
1938                    Group group = GroupLocalServiceUtil.getGroup(groupId);
1939    
1940                    long parentGroupId = groupId;
1941    
1942                    if (group.isLayout()) {
1943                            parentGroupId = group.getParentGroupId();
1944                    }
1945    
1946                    return parentGroupId;
1947            }
1948    
1949            public String getPathContext() {
1950                    return _pathContext;
1951            }
1952    
1953            public String getPathFriendlyURLPrivateGroup() {
1954                    return _pathFriendlyURLPrivateGroup;
1955            }
1956    
1957            public String getPathFriendlyURLPrivateUser() {
1958                    return _pathFriendlyURLPrivateUser;
1959            }
1960    
1961            public String getPathFriendlyURLPublic() {
1962                    return _pathFriendlyURLPublic;
1963            }
1964    
1965            public String getPathImage() {
1966                    return _pathImage;
1967            }
1968    
1969            public String getPathMain() {
1970                    return _pathMain;
1971            }
1972    
1973            public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1974                    if (Validator.isNull(friendlyURL)) {
1975                            return LayoutConstants.DEFAULT_PLID;
1976                    }
1977    
1978                    String[] urlParts = friendlyURL.split("\\/", 4);
1979    
1980                    if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1981                            (urlParts.length != 4)) {
1982    
1983                            return LayoutConstants.DEFAULT_PLID;
1984                    }
1985    
1986                    boolean privateLayout = true;
1987    
1988                    String urlPrefix = StringPool.SLASH + urlParts[1];
1989    
1990                    if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
1991                            privateLayout = false;
1992                    }
1993                    else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
1994                                     _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
1995    
1996                            privateLayout = true;
1997                    }
1998                    else {
1999                            return LayoutConstants.DEFAULT_PLID;
2000                    }
2001    
2002                    Group group = null;
2003    
2004                    try {
2005                            group = GroupLocalServiceUtil.getFriendlyURLGroup(
2006                                    companyId, StringPool.SLASH + urlParts[2]);
2007                    }
2008                    catch (Exception e) {
2009                    }
2010    
2011                    if (group != null) {
2012                            Layout layout = null;
2013    
2014                            try {
2015                                    String layoutFriendlyURL = null;
2016    
2017                                    if (urlParts.length == 4) {
2018                                            layoutFriendlyURL = StringPool.SLASH + urlParts[3];
2019                                    }
2020                                    else {
2021                                            layoutFriendlyURL = "/1";
2022                                    }
2023    
2024                                    layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2025                                            group.getGroupId(), privateLayout, layoutFriendlyURL);
2026    
2027                                    return layout.getPlid();
2028                            }
2029                            catch (Exception e) {
2030                            }
2031                    }
2032    
2033                    return LayoutConstants.DEFAULT_PLID;
2034            }
2035    
2036            public long getPlidFromPortletId(
2037                            long groupId, boolean privateLayout, String portletId)
2038                    throws PortalException, SystemException {
2039    
2040                    long plid = LayoutConstants.DEFAULT_PLID;
2041    
2042                    StringBundler sb = new StringBundler(5);
2043    
2044                    sb.append(groupId);
2045                    sb.append(StringPool.SPACE);
2046                    sb.append(privateLayout);
2047                    sb.append(StringPool.SPACE);
2048                    sb.append(portletId);
2049    
2050                    String key = sb.toString();
2051    
2052                    Long plidObj = _plidToPortletIdCache.get(key);
2053    
2054                    if (plidObj == null) {
2055                            plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
2056    
2057                            if (plid != LayoutConstants.DEFAULT_PLID) {
2058                                    _plidToPortletIdCache.put(key, plid);
2059                            }
2060                    }
2061                    else {
2062                            plid = plidObj.longValue();
2063    
2064                            boolean validPlid = false;
2065    
2066                            try {
2067                                    Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2068    
2069                                    LayoutTypePortlet layoutTypePortlet =
2070                                            (LayoutTypePortlet)layout.getLayoutType();
2071    
2072                                    if (layoutTypePortlet.hasDefaultScopePortletId(
2073                                                    groupId, portletId)) {
2074    
2075                                            validPlid = true;
2076                                    }
2077                            }
2078                            catch (Exception e) {
2079                            }
2080    
2081                            if (!validPlid) {
2082                                    _plidToPortletIdCache.remove(key);
2083    
2084                                    plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
2085    
2086                                    if (plid != LayoutConstants.DEFAULT_PLID) {
2087                                            _plidToPortletIdCache.put(key, plid);
2088                                    }
2089                            }
2090                    }
2091    
2092                    return plid;
2093            }
2094    
2095            public long getPlidFromPortletId(long groupId, String portletId)
2096                    throws PortalException, SystemException {
2097    
2098                    long plid = getPlidFromPortletId(groupId, false, portletId);
2099    
2100                    if (plid == LayoutConstants.DEFAULT_PLID) {
2101                            plid = getPlidFromPortletId(groupId, true, portletId);
2102                    }
2103    
2104                    if (plid == LayoutConstants.DEFAULT_PLID) {
2105                            if (_log.isDebugEnabled()) {
2106                                    _log.debug(
2107                                            "Portlet " + portletId +
2108                                                    " does not exist on a page in group " + groupId);
2109                            }
2110                    }
2111    
2112                    return plid;
2113            }
2114    
2115            public String getPortalLibDir() {
2116                    return _portalLibDir;
2117            }
2118    
2119            public int getPortalPort() {
2120                    return _portalPort;
2121            }
2122    
2123            public Properties getPortalProperties() {
2124                    return PropsUtil.getProperties();
2125            }
2126    
2127            public String getPortalURL(HttpServletRequest request) {
2128                    return getPortalURL(request, request.isSecure());
2129            }
2130    
2131            public String getPortalURL(HttpServletRequest request, boolean secure) {
2132                    return getPortalURL(
2133                            request.getServerName(), request.getServerPort(), secure);
2134            }
2135    
2136            public String getPortalURL(PortletRequest portletRequest) {
2137                    return getPortalURL(portletRequest, portletRequest.isSecure());
2138            }
2139    
2140            public String getPortalURL(PortletRequest portletRequest, boolean secure) {
2141                    return getPortalURL(
2142                            portletRequest.getServerName(), portletRequest.getServerPort(),
2143                            secure);
2144            }
2145    
2146            public String getPortalURL(
2147                    String serverName, int serverPort, boolean secure) {
2148    
2149                    StringBundler sb = new StringBundler();
2150    
2151                    if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
2152                            sb.append(Http.HTTPS_WITH_SLASH);
2153                    }
2154                    else {
2155                            sb.append(Http.HTTP_WITH_SLASH);
2156                    }
2157    
2158                    if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
2159                            sb.append(serverName);
2160                    }
2161                    else {
2162                            sb.append(PropsValues.WEB_SERVER_HOST);
2163                    }
2164    
2165                    if (!secure) {
2166                            if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
2167                                    if ((serverPort != Http.HTTP_PORT) &&
2168                                            (serverPort != Http.HTTPS_PORT)) {
2169    
2170                                            sb.append(StringPool.COLON);
2171                                            sb.append(serverPort);
2172                                    }
2173                            }
2174                            else {
2175                                    if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
2176                                            sb.append(StringPool.COLON);
2177                                            sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
2178                                    }
2179                            }
2180                    }
2181    
2182                    if (secure) {
2183                            if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
2184                                    if ((serverPort != Http.HTTP_PORT) &&
2185                                            (serverPort != Http.HTTPS_PORT)) {
2186    
2187                                            sb.append(StringPool.COLON);
2188                                            sb.append(serverPort);
2189                                    }
2190                            }
2191                            else {
2192                                    if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
2193                                            sb.append(StringPool.COLON);
2194                                            sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
2195                                    }
2196                            }
2197                    }
2198    
2199                    return sb.toString();
2200            }
2201    
2202            public String getPortalURL(ThemeDisplay themeDisplay)
2203                    throws PortalException, SystemException {
2204    
2205                    String serverName = themeDisplay.getServerName();
2206    
2207                    Layout layout = themeDisplay.getLayout();
2208    
2209                    if (layout != null) {
2210                            LayoutSet layoutSet = layout.getLayoutSet();
2211    
2212                            String virtualHost = layoutSet.getVirtualHost();
2213    
2214                            if (Validator.isNotNull(virtualHost)) {
2215                                    serverName = virtualHost;
2216                            }
2217                    }
2218    
2219                    return getPortalURL(
2220                            serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
2221            }
2222    
2223            public String getPortalWebDir() {
2224                    return _portalWebDir;
2225            }
2226    
2227            public List<KeyValuePair> getPortletBreadcrumbList(
2228                    HttpServletRequest request) {
2229    
2230                    return (List<KeyValuePair>)request.getAttribute(
2231                            WebKeys.PORTLET_BREADCRUMB_MAP);
2232            }
2233    
2234            public String getPortletDescription(
2235                    Portlet portlet, ServletContext servletContext, Locale locale) {
2236    
2237                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
2238                            portlet, servletContext);
2239    
2240                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
2241    
2242                    return resourceBundle.getString(
2243                            JavaConstants.JAVAX_PORTLET_DESCRIPTION);
2244            }
2245    
2246            public String getPortletDescription(Portlet portlet, User user) {
2247                    return getPortletDescription(portlet.getPortletId(), user);
2248            }
2249    
2250            public String getPortletDescription(String portletId, Locale locale) {
2251                    return LanguageUtil.get(
2252                            locale,
2253                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2254                                    StringPool.PERIOD).concat(portletId));
2255            }
2256    
2257            public String getPortletDescription(String portletId, String languageId) {
2258                    Locale locale = LocaleUtil.fromLanguageId(languageId);
2259    
2260                    return getPortletDescription(portletId, locale);
2261            }
2262    
2263            public String getPortletDescription(String portletId, User user) {
2264                    return LanguageUtil.get(
2265                            user.getLocale(),
2266                            JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
2267                                    StringPool.PERIOD).concat(portletId));
2268            }
2269    
2270            public Object[] getPortletFriendlyURLMapper(
2271                            long groupId, boolean privateLayout, String url,
2272                            Map<String, String[]> params, Map<String, Object> requestContext)
2273                    throws PortalException, SystemException {
2274    
2275                    boolean foundFriendlyURLMapper = false;
2276    
2277                    String friendlyURL = url;
2278                    String queryString = StringPool.BLANK;
2279    
2280                    List<Portlet> portlets =
2281                            PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
2282    
2283                    Iterator<Portlet> itr = portlets.iterator();
2284    
2285                    while (itr.hasNext()) {
2286                            Portlet portlet = itr.next();
2287    
2288                            FriendlyURLMapper friendlyURLMapper =
2289                                    portlet.getFriendlyURLMapperInstance();
2290    
2291                            if (url.endsWith(
2292                                            StringPool.SLASH + friendlyURLMapper.getMapping())) {
2293    
2294                                    url += StringPool.SLASH;
2295                            }
2296    
2297                            int pos = -1;
2298    
2299                            if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2300                                    pos = url.indexOf(
2301                                            FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
2302                                                    StringPool.SLASH);
2303                            }
2304                            else {
2305                                    pos = url.indexOf(
2306                                            StringPool.SLASH + friendlyURLMapper.getMapping() +
2307                                                    StringPool.SLASH);
2308                            }
2309    
2310                            if (pos != -1) {
2311                                    foundFriendlyURLMapper = true;
2312    
2313                                    friendlyURL = url.substring(0, pos);
2314    
2315                                    InheritableMap<String, String[]> actualParams =
2316                                            new InheritableMap<String, String[]>();
2317    
2318                                    if (params != null) {
2319                                            actualParams.setParentMap(params);
2320                                    }
2321    
2322                                    Map<String, String> prpIdentifiers =
2323                                            new HashMap<String, String>();
2324    
2325                                    Set<PublicRenderParameter> publicRenderParameters =
2326                                            portlet.getPublicRenderParameters();
2327    
2328                                    for (PublicRenderParameter publicRenderParameter :
2329                                                    publicRenderParameters) {
2330    
2331                                            QName qName = publicRenderParameter.getQName();
2332    
2333                                            String publicRenderParameterIdentifier =
2334                                                    qName.getLocalPart();
2335                                            String publicRenderParameterName =
2336                                                    PortletQNameUtil.getPublicRenderParameterName(qName);
2337    
2338                                            prpIdentifiers.put(
2339                                                    publicRenderParameterIdentifier,
2340                                                    publicRenderParameterName);
2341                                    }
2342    
2343                                    FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
2344    
2345                                    if (friendlyURLMapper.isCheckMappingWithPrefix()) {
2346                                            friendlyURLMapper.populateParams(
2347                                                    url.substring(pos + 2), actualParams,
2348                                                    requestContext);
2349                                    }
2350                                    else {
2351                                            friendlyURLMapper.populateParams(
2352                                                    url.substring(pos), actualParams, requestContext);
2353                                    }
2354    
2355                                    queryString =
2356                                            StringPool.AMPERSAND +
2357                                                    HttpUtil.parameterMapToString(actualParams, false);
2358    
2359                                    break;
2360                            }
2361                    }
2362    
2363                    if (!foundFriendlyURLMapper) {
2364                            int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
2365    
2366                            if (x != -1) {
2367                                    int y = url.indexOf(StringPool.SLASH, x + 3);
2368    
2369                                    if (y == -1) {
2370                                            y = url.length();
2371                                    }
2372    
2373                                    String ppid = url.substring(x + 3, y);
2374    
2375                                    if (Validator.isNotNull(ppid)) {
2376                                            friendlyURL = url.substring(0, x);
2377    
2378                                            Map<String, String[]> actualParams = null;
2379    
2380                                            if (params != null) {
2381                                                    actualParams = new HashMap<String, String[]>(params);
2382                                            }
2383                                            else {
2384                                                    actualParams = new HashMap<String, String[]>();
2385                                            }
2386    
2387                                            actualParams.put("p_p_id", new String[] {ppid});
2388                                            actualParams.put("p_p_lifecycle", new String[] {"0"});
2389                                            actualParams.put(
2390                                                    "p_p_state",
2391                                                    new String[] {WindowState.MAXIMIZED.toString()});
2392                                            actualParams.put(
2393                                                    "p_p_mode", new String[] {PortletMode.VIEW.toString()});
2394    
2395                                            queryString =
2396                                                    StringPool.AMPERSAND +
2397                                                            HttpUtil.parameterMapToString(actualParams, false);
2398                                    }
2399                            }
2400                    }
2401    
2402                    friendlyURL = StringUtil.replace(
2403                            friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
2404    
2405                    if (friendlyURL.endsWith(StringPool.SLASH)) {
2406                            friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
2407                    }
2408    
2409                    Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2410                            groupId, privateLayout, friendlyURL);
2411    
2412                    return new Object[] {layout, queryString};
2413            }
2414    
2415            public String getPortletId(HttpServletRequest request) {
2416                    PortletConfigImpl portletConfigImpl =
2417                            (PortletConfigImpl)request.getAttribute(
2418                                    JavaConstants.JAVAX_PORTLET_CONFIG);
2419    
2420                    if (portletConfigImpl != null) {
2421                            return portletConfigImpl.getPortletId();
2422                    }
2423                    else {
2424                            return null;
2425                    }
2426            }
2427    
2428            public String getPortletId(PortletRequest portletRequest) {
2429                    PortletConfigImpl portletConfigImpl =
2430                            (PortletConfigImpl)portletRequest.getAttribute(
2431                                    JavaConstants.JAVAX_PORTLET_CONFIG);
2432    
2433                    if (portletConfigImpl != null) {
2434                            return portletConfigImpl.getPortletId();
2435                    }
2436                    else {
2437                            return null;
2438                    }
2439            }
2440    
2441            public String getPortletNamespace(String portletId) {
2442                    return StringPool.UNDERLINE.concat(portletId).concat(
2443                            StringPool.UNDERLINE);
2444            }
2445    
2446            public String getPortletTitle(Portlet portlet, Locale locale) {
2447                    return getPortletTitle(portlet.getPortletId(), locale);
2448            }
2449    
2450            public String getPortletTitle(Portlet portlet, String languageId) {
2451                    return getPortletTitle(portlet.getPortletId(), languageId);
2452            }
2453    
2454            public String getPortletTitle(
2455                    Portlet portlet, ServletContext servletContext, Locale locale) {
2456    
2457                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
2458                            portlet, servletContext);
2459    
2460                    ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
2461    
2462                    return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
2463            }
2464    
2465            public String getPortletTitle(Portlet portlet, User user) {
2466                    return getPortletTitle(portlet.getPortletId(), user);
2467            }
2468    
2469            public String getPortletTitle(RenderResponse renderResponse) {
2470                    PortletResponseImpl portletResponseImpl =
2471                            PortletResponseImpl.getPortletResponseImpl(renderResponse);
2472    
2473                    return ((RenderResponseImpl)portletResponseImpl).getTitle();
2474            }
2475    
2476            public String getPortletTitle(String portletId, Locale locale) {
2477                    return LanguageUtil.get(
2478                            locale,
2479                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
2480                                    portletId));
2481            }
2482    
2483            public String getPortletTitle(String portletId, String languageId) {
2484                    Locale locale = LocaleUtil.fromLanguageId(languageId);
2485    
2486                    return getPortletTitle(portletId, locale);
2487            }
2488    
2489            public String getPortletTitle(String portletId, User user) {
2490                    return LanguageUtil.get(
2491                            user.getLocale(),
2492                            JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
2493                                    portletId));
2494            }
2495    
2496            public String getPortletXmlFileName() throws SystemException {
2497                    if (PrefsPropsUtil.getBoolean(
2498                                    PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
2499                                    PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
2500    
2501                            return PORTLET_XML_FILE_NAME_CUSTOM;
2502                    }
2503                    else {
2504                            return PORTLET_XML_FILE_NAME_STANDARD;
2505                    }
2506            }
2507    
2508            public PortletPreferences getPreferences(HttpServletRequest request) {
2509                    RenderRequest renderRequest = (RenderRequest)request.getAttribute(
2510                            JavaConstants.JAVAX_PORTLET_REQUEST);
2511    
2512                    PortletPreferences preferences = null;
2513    
2514                    if (renderRequest != null) {
2515                            PortletPreferencesWrapper preferencesWrapper =
2516                                    (PortletPreferencesWrapper)renderRequest.getPreferences();
2517    
2518                            preferences = preferencesWrapper.getPreferencesImpl();
2519                    }
2520    
2521                    return preferences;
2522            }
2523    
2524            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
2525                    PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
2526    
2527                    return portletBag.getPreferencesValidatorInstance();
2528            }
2529    
2530            public long getScopeGroupId(HttpServletRequest request)
2531                    throws PortalException, SystemException {
2532    
2533                    String portletId = getPortletId(request);
2534    
2535                    return getScopeGroupId(request, portletId);
2536            }
2537    
2538            public long getScopeGroupId(HttpServletRequest request, String portletId)
2539                    throws PortalException, SystemException {
2540    
2541                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2542    
2543                    long scopeGroupId = 0;
2544    
2545                    if (layout != null) {
2546                            Group group = layout.getGroup();
2547    
2548                            if (group.isControlPanel()) {
2549                                    long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
2550    
2551                                    if (doAsGroupId <= 0) {
2552                                            try {
2553                                                    Group guestGroup = GroupLocalServiceUtil.getGroup(
2554                                                            group.getCompanyId(), GroupConstants.GUEST);
2555    
2556                                                    doAsGroupId = guestGroup.getGroupId();
2557                                            }
2558                                            catch (Exception e) {
2559                                            }
2560                                    }
2561    
2562                                    if (doAsGroupId > 0) {
2563                                            scopeGroupId = doAsGroupId;
2564                                    }
2565    
2566                                    try {
2567                                            group = GroupLocalServiceUtil.getGroup(scopeGroupId);
2568    
2569                                            if (group.hasStagingGroup()) {
2570                                                    Group stagingGroup = group.getStagingGroup();
2571    
2572                                                    scopeGroupId = stagingGroup.getGroupId();
2573                                            }
2574                                    }
2575                                    catch (Exception e) {
2576                                    }
2577                            }
2578    
2579                            if ((portletId != null) &&
2580                                    (group.isStaged() || group.isStagingGroup())) {
2581    
2582                                    Group liveGroup = group;
2583    
2584                                    if (group.isStagingGroup()) {
2585                                            liveGroup = group.getLiveGroup();
2586                                    }
2587    
2588                                    if (liveGroup.isStaged() &&
2589                                            !liveGroup.isStagedPortlet(portletId)) {
2590    
2591                                            scopeGroupId = liveGroup.getGroupId();
2592                                    }
2593                            }
2594                    }
2595    
2596                    if (scopeGroupId <= 0) {
2597                            scopeGroupId = getScopeGroupId(layout, portletId);
2598                    }
2599    
2600                    return scopeGroupId;
2601            }
2602    
2603            public long getScopeGroupId(Layout layout) {
2604                    if (layout == null) {
2605                            return 0;
2606                    }
2607                    else {
2608                            return layout.getGroupId();
2609                    }
2610            }
2611    
2612            public long getScopeGroupId(Layout layout, String portletId) {
2613                    if (layout == null) {
2614                            return 0;
2615                    }
2616                    else {
2617                            if (Validator.isNotNull(portletId)) {
2618                                    try {
2619                                            PortletPreferences portletSetup =
2620                                                    PortletPreferencesFactoryUtil.getLayoutPortletSetup(
2621                                                            layout, portletId);
2622    
2623                                            String scopeLayoutUuid = GetterUtil.getString(
2624                                                    portletSetup.getValue("lfr-scope-layout-uuid", null));
2625    
2626                                            if (Validator.isNotNull(scopeLayoutUuid)) {
2627                                                    Layout scopeLayout =
2628                                                            LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
2629                                                                    scopeLayoutUuid, layout.getGroupId());
2630    
2631                                                    return scopeLayout.getScopeGroup().getGroupId();
2632                                            }
2633                                    }
2634                                    catch (Exception e) {
2635                                    }
2636                            }
2637    
2638                            return layout.getGroupId();
2639                    }
2640            }
2641    
2642            public long getScopeGroupId(long plid) {
2643                    Layout layout = null;
2644    
2645                    try {
2646                            layout = LayoutLocalServiceUtil.getLayout(plid);
2647                    }
2648                    catch (Exception e) {
2649                    }
2650    
2651                    return getScopeGroupId(layout);
2652            }
2653    
2654            public long getScopeGroupId(PortletRequest portletRequest)
2655                    throws PortalException, SystemException {
2656    
2657                    return getScopeGroupId(getHttpServletRequest(portletRequest));
2658            }
2659    
2660            public User getSelectedUser(HttpServletRequest request)
2661                    throws PortalException, SystemException {
2662    
2663                    return getSelectedUser(request, true);
2664            }
2665    
2666            public User getSelectedUser(
2667                            HttpServletRequest request, boolean checkPermission)
2668                    throws PortalException, SystemException {
2669    
2670                    long userId = ParamUtil.getLong(request, "p_u_i_d");
2671    
2672                    User user = null;
2673    
2674                    try {
2675                            if (checkPermission) {
2676                                    user = UserServiceUtil.getUserById(userId);
2677                            }
2678                            else {
2679                                    user = UserLocalServiceUtil.getUserById(userId);
2680                            }
2681                    }
2682                    catch (NoSuchUserException nsue) {
2683                    }
2684    
2685                    return user;
2686            }
2687    
2688            public User getSelectedUser(PortletRequest portletRequest)
2689                    throws PortalException, SystemException {
2690    
2691                    return getSelectedUser(portletRequest, true);
2692            }
2693    
2694            public User getSelectedUser(
2695                            PortletRequest portletRequest, boolean checkPermission)
2696                    throws PortalException, SystemException {
2697    
2698                    return getSelectedUser(
2699                            getHttpServletRequest(portletRequest), checkPermission);
2700            }
2701    
2702            public ServletContext getServletContext(
2703                    Portlet portlet, ServletContext servletContext) {
2704    
2705                    PortletConfig portletConfig = PortletConfigFactoryUtil.create(
2706                            portlet, servletContext);
2707    
2708                    PortletContextImpl portletContextImpl =
2709                            (PortletContextImpl)portletConfig.getPortletContext();
2710    
2711                    return portletContextImpl.getServletContext();
2712            }
2713    
2714            public SocialEquityActionMapping getSocialEquityActionMapping(
2715                    String name, String actionId) {
2716    
2717                    return ResourceActionsUtil.getSocialEquityActionMapping(name, actionId);
2718            }
2719    
2720            public List<SocialEquityActionMapping> getSocialEquityActionMappings(
2721                    String name) {
2722    
2723                    return ResourceActionsUtil.getSocialEquityActionMappings(name);
2724            }
2725    
2726            public String[] getSocialEquityClassNames() {
2727                    return ResourceActionsUtil.getSocialEquityClassNames();
2728            }
2729    
2730            public String getStaticResourceURL(
2731                    HttpServletRequest request, String uri) {
2732    
2733                    return getStaticResourceURL(request, uri, null, 0);
2734            }
2735    
2736            public String getStaticResourceURL(
2737                    HttpServletRequest request, String uri, long timestamp) {
2738    
2739                    return getStaticResourceURL(request, uri, null, timestamp);
2740            }
2741    
2742            public String getStaticResourceURL(
2743                    HttpServletRequest request, String uri, String queryString) {
2744    
2745                    return getStaticResourceURL(request, uri, queryString, 0);
2746            }
2747    
2748            public String getStaticResourceURL(
2749                    HttpServletRequest request, String uri, String queryString,
2750                    long timestamp) {
2751    
2752                    if (uri.contains(StringPool.QUESTION)) {
2753                            return uri;
2754                    }
2755    
2756                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2757                            WebKeys.THEME_DISPLAY);
2758    
2759                    Theme theme = themeDisplay.getTheme();
2760                    ColorScheme colorScheme = themeDisplay.getColorScheme();
2761    
2762                    Map<String, String[]> parameterMap = null;
2763    
2764                    if (Validator.isNotNull(queryString)) {
2765                            parameterMap = HttpUtil.getParameterMap(queryString);
2766                    }
2767    
2768                    StringBundler sb = new StringBundler();
2769    
2770                    // URI
2771    
2772                    sb.append(uri);
2773                    sb.append(StringPool.QUESTION);
2774    
2775                    // Browser id
2776    
2777                    if ((parameterMap == null) ||
2778                            (!parameterMap.containsKey("browserId"))) {
2779    
2780                            sb.append("&browserId=");
2781                            sb.append(BrowserSnifferUtil.getBrowserId(request));
2782                    }
2783    
2784                    // Theme and color scheme
2785    
2786                    if (uri.endsWith(".jsp")) {
2787                            if ((parameterMap == null) ||
2788                                    (!parameterMap.containsKey("themeId"))) {
2789    
2790                                    sb.append("&themeId=");
2791                                    sb.append(theme.getThemeId());
2792                            }
2793    
2794                            if ((parameterMap == null) ||
2795                                    (!parameterMap.containsKey("colorSchemeId"))) {
2796    
2797                                    sb.append("&colorSchemeId=");
2798                                    sb.append(colorScheme.getColorSchemeId());
2799                            }
2800                    }
2801    
2802                    // Minifier
2803    
2804                    if ((parameterMap == null) ||
2805                            (!parameterMap.containsKey("minifierType"))) {
2806    
2807                            String minifierType = StringPool.BLANK;
2808    
2809                            if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
2810                                    uri.endsWith("css/main.jsp")) {
2811    
2812                                    if (themeDisplay.isThemeCssFastLoad()) {
2813                                            minifierType = "css";
2814                                    }
2815                            }
2816                            else if (themeDisplay.isThemeJsFastLoad()) {
2817                                    minifierType = "js";
2818                            }
2819    
2820                            if (Validator.isNotNull(minifierType)) {
2821                                    sb.append("&minifierType=");
2822                                    sb.append(minifierType);
2823                            }
2824                    }
2825    
2826                    // Query string
2827    
2828                    if (Validator.isNotNull(queryString)) {
2829                            if (!queryString.startsWith(StringPool.AMPERSAND)) {
2830                                    sb.append(StringPool.AMPERSAND);
2831                            }
2832    
2833                            sb.append(queryString);
2834                    }
2835    
2836                    // Language id
2837    
2838                    sb.append("&languageId=");
2839                    sb.append(themeDisplay.getLanguageId());
2840    
2841                    // Timestamp
2842    
2843                    if ((parameterMap == null) || !parameterMap.containsKey("t")) {
2844                            if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
2845                                    ServletContext servletContext =
2846                                            (ServletContext)request.getAttribute(WebKeys.CTX);
2847    
2848                                    String uriRealPath = ServletContextUtil.getRealPath(
2849                                            servletContext, uri);
2850    
2851                                    if (uriRealPath != null) {
2852                                            File uriFile = new File(uriRealPath);
2853    
2854                                            if (uriFile.exists()) {
2855                                                    timestamp = uriFile.lastModified();
2856                                            }
2857                                    }
2858                            }
2859    
2860                            if (timestamp == 0) {
2861                                    timestamp = theme.getTimestamp();
2862                            }
2863    
2864                            sb.append("&t=");
2865                            sb.append(timestamp);
2866                    }
2867    
2868                    String url = sb.toString();
2869    
2870                    url = StringUtil.replace(url, "?&", StringPool.QUESTION);
2871    
2872                    return url;
2873            }
2874    
2875            public String getStrutsAction(HttpServletRequest request) {
2876                    String strutsAction = ParamUtil.getString(request, "struts_action");
2877    
2878                    if (Validator.isNotNull(strutsAction)) {
2879    
2880                            // This method should only return a Struts action if you're dealing
2881                            // with a regular HTTP servlet request, not a portlet HTTP servlet
2882                            // request.
2883    
2884                            return StringPool.BLANK;
2885                    }
2886    
2887                    return _getPortletParam(request, "struts_action");
2888            }
2889    
2890            public String[] getSystemCommunityRoles() {
2891                    return _allSystemCommunityRoles;
2892            }
2893    
2894            public String[] getSystemGroups() {
2895                    return _allSystemGroups;
2896            }
2897    
2898            public String[] getSystemOrganizationRoles() {
2899                    return _allSystemOrganizationRoles;
2900            }
2901    
2902            public String[] getSystemRoles() {
2903                    return _allSystemRoles;
2904            }
2905    
2906            public UploadServletRequest getUploadServletRequest(
2907                    HttpServletRequest request) {
2908    
2909                    HttpServletRequestWrapper requestWrapper = null;
2910    
2911                    if (request instanceof HttpServletRequestWrapper) {
2912                            requestWrapper = (HttpServletRequestWrapper)request;
2913                    }
2914    
2915                    UploadServletRequest uploadRequest = null;
2916    
2917                    while (uploadRequest == null) {
2918    
2919                            // Find the underlying UploadServletRequest wrapper. For example,
2920                            // WebSphere wraps all requests with ProtectedServletRequest.
2921    
2922                            if (requestWrapper instanceof UploadServletRequest) {
2923                                    uploadRequest = (UploadServletRequest)requestWrapper;
2924                            }
2925                            else {
2926                                    HttpServletRequest parentRequest =
2927                                            (HttpServletRequest)requestWrapper.getRequest();
2928    
2929                                    if (!(parentRequest instanceof HttpServletRequestWrapper)) {
2930    
2931                                            // This block should never be reached unless this method is
2932                                            // called from a hot deployable portlet. See LayoutAction.
2933    
2934                                            uploadRequest = new UploadServletRequestImpl(parentRequest);
2935    
2936                                            break;
2937                                    }
2938                                    else {
2939                                            requestWrapper = (HttpServletRequestWrapper)parentRequest;
2940                                    }
2941                            }
2942                    }
2943    
2944                    return uploadRequest;
2945            }
2946    
2947            public UploadPortletRequest getUploadPortletRequest(
2948                    PortletRequest portletRequest) {
2949    
2950                    PortletRequestImpl portletRequestImpl =
2951                            (PortletRequestImpl)portletRequest;
2952    
2953                    DynamicServletRequest dynamicRequest =
2954                            (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
2955    
2956                    HttpServletRequestWrapper requestWrapper =
2957                            (HttpServletRequestWrapper)dynamicRequest.getRequest();
2958    
2959                    UploadServletRequest uploadRequest = getUploadServletRequest(
2960                            requestWrapper);
2961    
2962                    return new UploadPortletRequestImpl(
2963                            uploadRequest,
2964                            PortalUtil.getPortletNamespace(
2965                                    portletRequestImpl.getPortletName()));
2966            }
2967    
2968            public Date getUptime() {
2969                    return _UP_TIME;
2970            }
2971    
2972            public String getURLWithSessionId(String url, String sessionId) {
2973                    if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
2974                            return url;
2975                    }
2976    
2977                    // LEP-4787
2978    
2979                    int x = url.indexOf(StringPool.SEMICOLON);
2980    
2981                    if (x != -1) {
2982                            return url;
2983                    }
2984    
2985                    x = url.indexOf(StringPool.QUESTION);
2986    
2987                    if (x != -1) {
2988                            StringBundler sb = new StringBundler(4);
2989    
2990                            sb.append(url.substring(0, x));
2991                            sb.append(_JSESSIONID);
2992                            sb.append(sessionId);
2993                            sb.append(url.substring(x));
2994    
2995                            return sb.toString();
2996                    }
2997    
2998                    // In IE6, http://www.abc.com;jsessionid=XYZ does not work, but
2999                    // http://www.abc.com/;jsessionid=XYZ does work.
3000    
3001                    x = url.indexOf(StringPool.DOUBLE_SLASH);
3002    
3003                    StringBundler sb = new StringBundler(4);
3004    
3005                    sb.append(url);
3006    
3007                    if (x != -1) {
3008                            int y = url.lastIndexOf(StringPool.SLASH);
3009    
3010                            if (x + 1 == y) {
3011                                    sb.append(StringPool.SLASH);
3012                            }
3013                    }
3014    
3015                    sb.append(_JSESSIONID);
3016                    sb.append(sessionId);
3017    
3018                    return sb.toString();
3019            }
3020    
3021            public User getUser(HttpServletRequest request)
3022                    throws PortalException, SystemException {
3023    
3024                    long userId = getUserId(request);
3025    
3026                    if (userId <= 0) {
3027    
3028                            // Portlet WARs may have the correct remote user and not have the
3029                            // correct user id because the user id is saved in the session
3030                            // and may not be accessible by the portlet WAR's session. This
3031                            // behavior is inconsistent across different application servers.
3032    
3033                            String remoteUser = request.getRemoteUser();
3034    
3035                            if (remoteUser == null) {
3036                                    return null;
3037                            }
3038    
3039                            userId = GetterUtil.getLong(remoteUser);
3040                    }
3041    
3042                    User user = (User)request.getAttribute(WebKeys.USER);
3043    
3044                    if (user == null) {
3045                            user = UserLocalServiceUtil.getUserById(userId);
3046    
3047                            request.setAttribute(WebKeys.USER, user);
3048                    }
3049    
3050                    return user;
3051            }
3052    
3053            public User getUser(PortletRequest portletRequest)
3054                    throws PortalException, SystemException {
3055    
3056                    return getUser(getHttpServletRequest(portletRequest));
3057            }
3058    
3059            public long getUserId(HttpServletRequest request) {
3060                    Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
3061    
3062                    if (userIdObj != null) {
3063                            return userIdObj.longValue();
3064                    }
3065    
3066                    String path = GetterUtil.getString(request.getPathInfo());
3067                    String strutsAction = getStrutsAction(request);
3068                    String actionName = _getPortletParam(request, "actionName");
3069    
3070                    boolean alwaysAllowDoAsUser = false;
3071    
3072                    if (path.equals("/portal/fckeditor") ||
3073                            path.equals("/portal/session_click") ||
3074                            strutsAction.equals("/document_library/edit_file_entry") ||
3075                            strutsAction.equals("/image_gallery/edit_image") ||
3076                            strutsAction.equals("/wiki/edit_page_attachment") ||
3077                            actionName.equals("addFile")) {
3078    
3079                            alwaysAllowDoAsUser = true;
3080                    }
3081    
3082                    if ((!PropsValues.PORTAL_JAAS_ENABLE &&
3083                              PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
3084                            (alwaysAllowDoAsUser)) {
3085    
3086                            String doAsUserIdString = ParamUtil.getString(
3087                                    request, "doAsUserId");
3088    
3089                            try {
3090                                    long doAsUserId = getDoAsUserId(
3091                                            request, doAsUserIdString, alwaysAllowDoAsUser);
3092    
3093                                    if (doAsUserId > 0) {
3094                                            if (_log.isDebugEnabled()) {
3095                                                    _log.debug("Impersonating user " + doAsUserId);
3096                                            }
3097    
3098                                            return doAsUserId;
3099                                    }
3100                            }
3101                            catch (Exception e) {
3102                                    _log.error("Unable to impersonate user " + doAsUserIdString, e);
3103                            }
3104                    }
3105    
3106                    HttpSession session = request.getSession();
3107    
3108                    userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
3109    
3110                    if (userIdObj != null) {
3111                            request.setAttribute(WebKeys.USER_ID, userIdObj);
3112    
3113                            return userIdObj.longValue();
3114                    }
3115                    else {
3116                            return 0;
3117                    }
3118            }
3119    
3120            public long getUserId(PortletRequest portletRequest) {
3121                    return getUserId(getHttpServletRequest(portletRequest));
3122            }
3123    
3124            public String getUserName(long userId, String defaultUserName) {
3125                    return getUserName(
3126                            userId, defaultUserName, UserAttributes.USER_NAME_FULL);
3127            }
3128    
3129            public String getUserName(
3130                    long userId, String defaultUserName, HttpServletRequest request) {
3131    
3132                    return getUserName(
3133                            userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
3134            }
3135    
3136            public String getUserName(
3137                    long userId, String defaultUserName, String userAttribute) {
3138    
3139                    return getUserName(userId, defaultUserName, userAttribute, null);
3140            }
3141    
3142            public String getUserName(
3143                    long userId, String defaultUserName, String userAttribute,
3144                    HttpServletRequest request) {
3145    
3146                    String userName = defaultUserName;
3147    
3148                    try {
3149                            User user = UserLocalServiceUtil.getUserById(userId);
3150    
3151                            if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
3152                                    userName = user.getFullName();
3153                            }
3154                            else {
3155                                    userName = user.getScreenName();
3156                            }
3157    
3158                            if (request != null) {
3159                                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3160    
3161                                    PortletURL portletURL = new PortletURLImpl(
3162                                            request, PortletKeys.DIRECTORY, layout.getPlid(),
3163                                            PortletRequest.RENDER_PHASE);
3164    
3165                                    portletURL.setWindowState(WindowState.MAXIMIZED);
3166                                    portletURL.setPortletMode(PortletMode.VIEW);
3167    
3168                                    portletURL.setParameter(
3169                                            "struts_action", "/directory/view_user");
3170                                    portletURL.setParameter(
3171                                            "p_u_i_d", String.valueOf(user.getUserId()));
3172    
3173                                    userName =
3174                                            "<a href=\"" + portletURL.toString() + "\">" +
3175                                                    HtmlUtil.escape(userName) + "</a>";
3176                            }
3177                    }
3178                    catch (Exception e) {
3179                    }
3180    
3181                    return userName;
3182            }
3183    
3184            public String getUserPassword(HttpServletRequest request) {
3185                    HttpSession session = request.getSession();
3186    
3187                    return getUserPassword(session);
3188            }
3189    
3190            public String getUserPassword(HttpSession session) {
3191                    return (String)session.getAttribute(WebKeys.USER_PASSWORD);
3192            }
3193    
3194            public String getUserPassword(PortletRequest portletRequest) {
3195                    return getUserPassword(getHttpServletRequest(portletRequest));
3196            }
3197    
3198            public String getUserValue(long userId, String param, String defaultValue)
3199                    throws SystemException {
3200    
3201                    if (Validator.isNotNull(defaultValue)) {
3202                            return defaultValue;
3203                    }
3204                    else {
3205                            try {
3206                                    User user = UserLocalServiceUtil.getUserById(userId);
3207    
3208                                    return BeanPropertiesUtil.getString(user, param, defaultValue);
3209                            }
3210                            catch (PortalException pe) {
3211                                    return StringPool.BLANK;
3212                            }
3213                    }
3214            }
3215    
3216            public long getValidUserId(long companyId, long userId)
3217                    throws PortalException, SystemException {
3218    
3219                    try {
3220                            User user = UserLocalServiceUtil.getUser(userId);
3221    
3222                            if (user.getCompanyId() == companyId) {
3223                                    return user.getUserId();
3224                            }
3225                            else {
3226                                    return userId;
3227                            }
3228                    }
3229                    catch (NoSuchUserException nsue) {
3230                            return UserLocalServiceUtil.getDefaultUserId(companyId);
3231                    }
3232            }
3233    
3234            public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
3235                    throws PortalException, SystemException {
3236    
3237                    return _getServletURL(
3238                            portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
3239            }
3240    
3241            public boolean isAllowAddPortletDefaultResource(
3242                            HttpServletRequest request, Portlet portlet)
3243                    throws PortalException, SystemException {
3244    
3245                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3246                            WebKeys.THEME_DISPLAY);
3247    
3248                    Layout layout = themeDisplay.getLayout();
3249                    LayoutTypePortlet layoutTypePortlet =
3250                            themeDisplay.getLayoutTypePortlet();
3251    
3252                    String portletId = portlet.getPortletId();
3253    
3254                    Boolean renderPortletResource = (Boolean)request.getAttribute(
3255                            WebKeys.RENDER_PORTLET_RESOURCE);
3256    
3257                    if (renderPortletResource != null) {
3258                            boolean runtimePortlet = renderPortletResource.booleanValue();
3259    
3260                            if (runtimePortlet) {
3261                                    return true;
3262                            }
3263                    }
3264    
3265                    if (layout.isTypePanel()) {
3266                            return true;
3267                    }
3268    
3269                    if (layout.isTypeControlPanel() &&
3270                            isControlPanelPortlet(portletId, themeDisplay)) {
3271    
3272                            return true;
3273                    }
3274    
3275                    if (layout.isTypePortlet() &&
3276                            layoutTypePortlet.hasPortletId(portletId)) {
3277    
3278                            return true;
3279                    }
3280    
3281                    if (themeDisplay.isSignedIn() &&
3282                            (portletId.equals(PortletKeys.LAYOUT_CONFIGURATION) ||
3283                             portletId.equals(PortletKeys.LAYOUT_MANAGEMENT))) {
3284    
3285                            PermissionChecker permissionChecker =
3286                                    themeDisplay.getPermissionChecker();
3287    
3288                            Group group = layout.getGroup();
3289    
3290                            if (group.isCommunity() || group.isUserGroup()) {
3291                                    long scopeGroupId = themeDisplay.getScopeGroupId();
3292    
3293                                    if (GroupPermissionUtil.contains(
3294                                                    permissionChecker, scopeGroupId,
3295                                                    ActionKeys.MANAGE_LAYOUTS) ||
3296                                            GroupPermissionUtil.contains(
3297                                                    permissionChecker, scopeGroupId,
3298                                                    ActionKeys.PUBLISH_STAGING) ||
3299                                            LayoutPermissionUtil.contains(
3300                                                    permissionChecker, layout, ActionKeys.UPDATE)) {
3301    
3302                                            return true;
3303                                    }
3304                            }
3305                            else if (group.isCompany()) {
3306                                    if (permissionChecker.isCompanyAdmin()) {
3307                                            return true;
3308                                    }
3309                            }
3310                            else if (group.isLayoutPrototype()) {
3311                                    long layoutPrototypeId = group.getClassPK();
3312    
3313                                    if (LayoutPrototypePermissionUtil.contains(
3314                                                    permissionChecker, layoutPrototypeId,
3315                                                    ActionKeys.UPDATE)) {
3316    
3317                                            return true;
3318                                    }
3319                            }
3320                            else if (group.isLayoutSetPrototype()) {
3321                                    long layoutSetPrototypeId = group.getClassPK();
3322    
3323                                    if (LayoutSetPrototypePermissionUtil.contains(
3324                                                    permissionChecker, layoutSetPrototypeId,
3325                                                    ActionKeys.UPDATE)) {
3326    
3327                                            return true;
3328                                    }
3329                            }
3330                            else if (group.isOrganization()) {
3331                                    long organizationId = group.getClassPK();
3332    
3333                                    if (OrganizationPermissionUtil.contains(
3334                                                    permissionChecker, organizationId,
3335                                                    ActionKeys.MANAGE_LAYOUTS)) {
3336    
3337                                            return true;
3338                                    }
3339                            }
3340                            else if (group.isUser()) {
3341                                    return true;
3342                            }
3343                    }
3344    
3345                    if (portlet.isAddDefaultResource()) {
3346                            if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
3347                                    return true;
3348                            }
3349    
3350                            if (_portletAddDefaultResourceCheckWhitelist.contains(portletId)) {
3351                                    return true;
3352                            }
3353    
3354                            String strutsAction = ParamUtil.getString(request, "struts_action");
3355    
3356                            if (_portletAddDefaultResourceCheckWhitelistActions.contains(
3357                                            strutsAction)) {
3358    
3359                                    return true;
3360                            }
3361    
3362                            String requestPortletAuthenticationToken = ParamUtil.getString(
3363                                    request, "p_p_auth");
3364    
3365                            if (Validator.isNotNull(requestPortletAuthenticationToken)) {
3366                                    String actualPortletAuthenticationToken =
3367                                            AuthTokenUtil.getToken(
3368                                                    request, layout.getPlid(), portletId);
3369    
3370                                    if (requestPortletAuthenticationToken.equals(
3371                                                    actualPortletAuthenticationToken)) {
3372    
3373                                            return true;
3374                                    }
3375                            }
3376                    }
3377    
3378                    return false;
3379            }
3380    
3381            public boolean isCommunityAdmin(User user, long groupId) throws Exception {
3382                    PermissionChecker permissionChecker =
3383                            PermissionCheckerFactoryUtil.create(user, true);
3384    
3385                    return permissionChecker.isCommunityAdmin(groupId);
3386            }
3387    
3388            public boolean isCommunityOwner(User user, long groupId) throws Exception {
3389                    PermissionChecker permissionChecker =
3390                            PermissionCheckerFactoryUtil.create(user, true);
3391    
3392                    return permissionChecker.isCommunityOwner(groupId);
3393            }
3394    
3395            public boolean isCompanyAdmin(User user) throws Exception {
3396                    PermissionChecker permissionChecker =
3397                            PermissionCheckerFactoryUtil.create(user, true);
3398    
3399                    return permissionChecker.isCompanyAdmin();
3400            }
3401    
3402            public boolean isControlPanelPortlet(
3403                            String portletId, String category, ThemeDisplay themeDisplay)
3404                    throws SystemException {
3405    
3406                    List<Portlet> portlets = getControlPanelPortlets(
3407                            category, themeDisplay);
3408    
3409                    for (Portlet portlet : portlets) {
3410                            if (portlet.getPortletId().equals(portletId)) {
3411                                    return true;
3412                            }
3413                    }
3414    
3415                    return false;
3416            }
3417    
3418            public boolean isControlPanelPortlet(
3419                            String portletId, ThemeDisplay themeDisplay)
3420                    throws SystemException {
3421    
3422                    for (String category : PortletCategoryKeys.ALL) {
3423                            if (isControlPanelPortlet(portletId, category, themeDisplay)) {
3424                                    return true;
3425                            }
3426                    }
3427    
3428                    return false;
3429            }
3430    
3431            public boolean isLayoutFirstPageable(Layout layout) {
3432                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3433    
3434                    return layoutSettings.isFirstPageable();
3435            }
3436    
3437            public boolean isLayoutFirstPageable(String type) {
3438                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3439    
3440                    return layoutSettings.isFirstPageable();
3441            }
3442    
3443            public boolean isLayoutFriendliable(Layout layout) {
3444                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3445    
3446                    return layoutSettings.isURLFriendliable();
3447            }
3448    
3449            public boolean isLayoutFriendliable(String type) {
3450                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3451    
3452                    return layoutSettings.isURLFriendliable();
3453            }
3454    
3455            public boolean isLayoutParentable(Layout layout) {
3456                    return isLayoutParentable(layout.getType());
3457            }
3458    
3459            public boolean isLayoutParentable(String type) {
3460                    LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
3461    
3462                    return layoutSettings.isParentable();
3463            }
3464    
3465            public boolean isLayoutSitemapable(Layout layout) {
3466                    if (layout.isPrivateLayout()) {
3467                            return false;
3468                    }
3469    
3470                    LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
3471    
3472                    return layoutSettings.isSitemapable();
3473            }
3474    
3475            public boolean isMethodGet(PortletRequest portletRequest) {
3476                    HttpServletRequest request = getHttpServletRequest(portletRequest);
3477    
3478                    String method = GetterUtil.getString(request.getMethod());
3479    
3480                    if (method.equalsIgnoreCase(HttpMethods.GET)) {
3481                            return true;
3482                    }
3483                    else {
3484                            return false;
3485                    }
3486            }
3487    
3488            public boolean isMethodPost(PortletRequest portletRequest) {
3489                    HttpServletRequest request = getHttpServletRequest(portletRequest);
3490    
3491                    String method = GetterUtil.getString(request.getMethod());
3492    
3493                    if (method.equalsIgnoreCase(HttpMethods.POST)) {
3494                            return true;
3495                    }
3496                    else {
3497                            return false;
3498                    }
3499            }
3500    
3501            public boolean isOmniadmin(long userId) {
3502                    return OmniadminUtil.isOmniadmin(userId);
3503            }
3504    
3505            public boolean isReservedParameter(String name) {
3506                    return _reservedParams.contains(name);
3507            }
3508    
3509            public boolean isSystemGroup(String groupName) {
3510                    if (groupName == null) {
3511                            return false;
3512                    }
3513    
3514                    groupName = groupName.trim();
3515    
3516                    int pos = Arrays.binarySearch(
3517                            _sortedSystemGroups, groupName, new StringComparator());
3518    
3519                    if (pos >= 0) {
3520                            return true;
3521                    }
3522                    else {
3523                            return false;
3524                    }
3525            }
3526    
3527            public boolean isSystemRole(String roleName) {
3528                    if (roleName == null) {
3529                            return false;
3530                    }
3531    
3532                    roleName = roleName.trim();
3533    
3534                    int pos = Arrays.binarySearch(
3535                            _sortedSystemRoles, roleName, new StringComparator());
3536    
3537                    if (pos >= 0) {
3538                            return true;
3539                    }
3540                    else {
3541                            pos = Arrays.binarySearch(
3542                                    _sortedSystemCommunityRoles, roleName, new StringComparator());
3543    
3544                            if (pos >= 0) {
3545                                    return true;
3546                            }
3547                            else {
3548                                    pos = Arrays.binarySearch(
3549                                            _sortedSystemOrganizationRoles, roleName,
3550                                            new StringComparator());
3551    
3552                                    if (pos >= 0) {
3553                                            return true;
3554                                    }
3555                            }
3556                    }
3557    
3558                    return false;
3559            }
3560    
3561            public boolean isUpdateAvailable() throws SystemException {
3562                    return PluginPackageUtil.isUpdateAvailable();
3563            }
3564    
3565            public boolean isValidResourceId(String resourceId) {
3566                    if (Validator.isNull(resourceId)) {
3567                            return true;
3568                    }
3569    
3570                    Matcher matcher = _bannedRresourceIdPattern.matcher(resourceId);
3571    
3572                    if (matcher.matches()) {
3573                            return false;
3574                    }
3575    
3576                    return true;
3577            }
3578    
3579            public void removePortalPortEventListener(
3580                    PortalPortEventListener portalPortEventListener) {
3581    
3582                    _portalPortEventListeners.remove(portalPortEventListener);
3583            }
3584    
3585            public String renderPage(
3586                            ServletContext servletContext, HttpServletRequest request,
3587                            HttpServletResponse response, String path)
3588                    throws IOException, ServletException {
3589    
3590                    RequestDispatcher requestDispatcher =
3591                            servletContext.getRequestDispatcher(path);
3592    
3593                    StringServletResponse stringResponse = new StringServletResponse(
3594                            response);
3595    
3596                    requestDispatcher.include(request, stringResponse);
3597    
3598                    return stringResponse.getString();
3599            }
3600    
3601            public String renderPortlet(
3602                            ServletContext servletContext, HttpServletRequest request,
3603                            HttpServletResponse response, Portlet portlet, String queryString,
3604                            boolean writeOutput)
3605                    throws IOException, ServletException {
3606    
3607                    return renderPortlet(
3608                            servletContext, request, response, portlet, queryString, null, null,
3609                            null, writeOutput);
3610            }
3611    
3612            public String renderPortlet(
3613                            ServletContext servletContext, HttpServletRequest request,
3614                            HttpServletResponse response, Portlet portlet, String queryString,
3615                            String columnId, Integer columnPos, Integer columnCount,
3616                            boolean writeOutput)
3617                    throws IOException, ServletException {
3618    
3619                    return renderPortlet(
3620                            servletContext, request, response, portlet, queryString, columnId,
3621                            columnPos, columnCount, null, writeOutput);
3622            }
3623    
3624            public String renderPortlet(
3625                            ServletContext servletContext, HttpServletRequest request,
3626                            HttpServletResponse response, Portlet portlet, String queryString,
3627                            String columnId, Integer columnPos, Integer columnCount,
3628                            String path, boolean writeOutput)
3629                    throws IOException, ServletException {
3630    
3631                    queryString = GetterUtil.getString(queryString);
3632                    columnId = GetterUtil.getString(columnId);
3633    
3634                    if (columnPos == null) {
3635                            columnPos = Integer.valueOf(0);
3636                    }
3637    
3638                    if (columnCount == null) {
3639                            columnCount = Integer.valueOf(0);
3640                    }
3641    
3642                    request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
3643                    request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
3644                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
3645                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
3646                    request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
3647    
3648                    if (path == null) {
3649                            path = "/html/portal/render_portlet.jsp";
3650                    }
3651    
3652                    RequestDispatcher requestDispatcher =
3653                            servletContext.getRequestDispatcher(path);
3654    
3655                    UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
3656    
3657                    PipingServletResponse pipingServletResponse = new PipingServletResponse(
3658                            response, unsyncStringWriter);
3659    
3660                    requestDispatcher.include(request, pipingServletResponse);
3661    
3662                    boolean showPortlet = true;
3663    
3664                    Boolean portletConfiguratorVisibility = (Boolean)request.getAttribute(
3665                            WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
3666    
3667                    if (portletConfiguratorVisibility != null) {
3668                            ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3669                                    WebKeys.THEME_DISPLAY);
3670    
3671                            try {
3672                                    if (!PortletPermissionUtil.contains(
3673                                                    themeDisplay.getPermissionChecker(),
3674                                                    themeDisplay.getPlid(), portlet.getPortletId(),
3675                                                    ActionKeys.CONFIGURATION)) {
3676    
3677                                            showPortlet = false;
3678                                    }
3679                            }
3680                            catch (Exception e) {
3681                                    throw new ServletException(e);
3682                            }
3683    
3684                            request.removeAttribute(WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
3685                    }
3686    
3687                    if (showPortlet) {
3688                            if (writeOutput) {
3689                                    response.setContentType(ContentTypes.TEXT_HTML_UTF8);
3690    
3691                                    StringBundler sb = unsyncStringWriter.getStringBundler();
3692    
3693                                    sb.writeTo(response.getWriter());
3694    
3695                                    return StringPool.BLANK;
3696                            }
3697                            else {
3698                                    return unsyncStringWriter.toString();
3699                            }
3700                    }
3701                    else {
3702                            return StringPool.BLANK;
3703                    }
3704            }
3705    
3706            public void sendError(
3707                            Exception e, ActionRequest actionRequest,
3708                            ActionResponse actionResponse)
3709                    throws IOException {
3710    
3711                    sendError(0, e, actionRequest, actionResponse);
3712            }
3713    
3714            public void sendError(
3715                            Exception e, HttpServletRequest request,
3716                            HttpServletResponse response)
3717                    throws IOException, ServletException {
3718    
3719                    sendError(0, e, request, response);
3720            }
3721    
3722            public void sendError(
3723                            int status, Exception e, ActionRequest actionRequest,
3724                            ActionResponse actionResponse)
3725                    throws IOException {
3726    
3727                    StringBundler sb = new StringBundler(7);
3728    
3729                    sb.append(_pathMain);
3730                    sb.append("/portal/status?status=");
3731                    sb.append(status);
3732                    sb.append("&exception=");
3733                    sb.append(e.getClass().getName());
3734                    sb.append("&previousURL=");
3735                    sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
3736    
3737                    actionResponse.sendRedirect(sb.toString());
3738            }
3739    
3740            public void sendError(
3741                            int status, Exception e, HttpServletRequest request,
3742                            HttpServletResponse response)
3743                    throws IOException, ServletException {
3744    
3745                    if (_log.isInfoEnabled()) {
3746                            String currentURL = (String)request.getAttribute(
3747                                    WebKeys.CURRENT_URL);
3748    
3749                            _log.info(
3750                                    "Current URL " + currentURL + " generates exception: " +
3751                                            e.getMessage());
3752                    }
3753    
3754                    if (e instanceof NoSuchImageException) {
3755                            if (_logImageServlet.isWarnEnabled()) {
3756                                    _logImageServlet.warn(e, e);
3757                            }
3758                    }
3759                    else if ((e instanceof PortalException) && _log.isInfoEnabled()) {
3760                            _log.info(e, e);
3761                    }
3762                    else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
3763                            _log.warn(e, e);
3764                    }
3765    
3766                    if (response.isCommitted()) {
3767                            return;
3768                    }
3769    
3770                    if (status == 0) {
3771                            if (e instanceof PrincipalException) {
3772                                    status = HttpServletResponse.SC_FORBIDDEN;
3773                            }
3774                            else {
3775                                    String name = e.getClass().getName();
3776    
3777                                    name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
3778    
3779                                    if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
3780                                            status = HttpServletResponse.SC_NOT_FOUND;
3781                                    }
3782                            }
3783    
3784                            if (status == 0) {
3785    
3786                                    // LPS-5352
3787    
3788                                    if (PropsValues.TCK_URL) {
3789                                            status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
3790                                    }
3791                                    else {
3792                                            status = HttpServletResponse.SC_BAD_REQUEST;
3793                                    }
3794                            }
3795                    }
3796    
3797                    HttpSession session = request.getSession();
3798    
3799                    ServletContext servletContext = session.getServletContext();
3800    
3801                    String redirect = PATH_MAIN + "/portal/status";
3802    
3803                    if (e instanceof NoSuchLayoutException &&
3804                            Validator.isNotNull(
3805                                    PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
3806    
3807                            response.setStatus(status);
3808    
3809                            redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
3810    
3811                            RequestDispatcher requestDispatcher =
3812                                    servletContext.getRequestDispatcher(redirect);
3813    
3814                            if (requestDispatcher != null) {
3815                                    requestDispatcher.forward(request, response);
3816                            }
3817                    }
3818                    else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
3819                            response.setStatus(status);
3820    
3821                            SessionErrors.add(request, e.getClass().getName(), e);
3822    
3823                            RequestDispatcher requestDispatcher =
3824                                    servletContext.getRequestDispatcher(redirect);
3825    
3826                            if (requestDispatcher != null) {
3827                                    requestDispatcher.forward(request, response);
3828                            }
3829                    }
3830                    else {
3831                            if (e != null) {
3832                                    response.sendError(status, e.getMessage());
3833                            }
3834                            else {
3835                                    response.sendError(status);
3836                            }
3837                    }
3838            }
3839    
3840            /**
3841             * Sets the description for a page. This overrides the existing page
3842             * description.
3843             */
3844            public void setPageDescription(
3845                    String description, HttpServletRequest request) {
3846    
3847                    request.setAttribute(WebKeys.PAGE_DESCRIPTION, description);
3848            }
3849    
3850            /**
3851             * Sets the keywords for a page. This overrides the existing page keywords.
3852             */
3853            public void setPageKeywords(String keywords, HttpServletRequest request) {
3854                    request.removeAttribute(WebKeys.PAGE_KEYWORDS);
3855    
3856                    addPageKeywords(keywords, request);
3857            }
3858    
3859            /**
3860             * Sets the subtitle for a page. This overrides the existing page subtitle.
3861             */
3862            public void setPageSubtitle(String subtitle, HttpServletRequest request) {
3863                    request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
3864            }
3865    
3866            /**
3867             * Sets the whole title for a page. This overrides the existing page whole
3868             * title.
3869             */
3870            public void setPageTitle(String title, HttpServletRequest request) {
3871                    request.setAttribute(WebKeys.PAGE_TITLE, title);
3872            }
3873    
3874            /**
3875             * Sets the port obtained on the first request to the portal.
3876             */
3877            public void setPortalPort(HttpServletRequest request) {
3878                    if (_portalPort == -1) {
3879                            _portalPortLock.lock();
3880    
3881                            try {
3882                                    if (_portalPort == -1) {
3883                                            _portalPort = request.getServerPort();
3884                                    }
3885                            }
3886                            finally {
3887                                    _portalPortLock.unlock();
3888                            }
3889    
3890                            notifyPortalPortEventListeners(_portalPort);
3891                    }
3892            }
3893    
3894            public void storePreferences(PortletPreferences preferences)
3895                    throws IOException, ValidatorException {
3896    
3897                    PortletPreferencesWrapper preferencesWrapper =
3898                            (PortletPreferencesWrapper)preferences;
3899    
3900                    PortletPreferencesImpl preferencesImpl =
3901                            preferencesWrapper.getPreferencesImpl();
3902    
3903                    preferencesImpl.store();
3904            }
3905    
3906            public String transformCustomSQL(String sql) {
3907                    if ((_customSqlClassNames == null) ||
3908                            (_customSqlClassNameIds == null)) {
3909    
3910                            _initCustomSQL();
3911                    }
3912    
3913                    return StringUtil.replace(
3914                            sql, _customSqlClassNames, _customSqlClassNameIds);
3915            }
3916    
3917            public PortletMode updatePortletMode(
3918                    String portletId, User user, Layout layout, PortletMode portletMode,
3919                    HttpServletRequest request) {
3920    
3921                    LayoutTypePortlet layoutType =
3922                            (LayoutTypePortlet)layout.getLayoutType();
3923    
3924                    if (portletMode == null || Validator.isNull(portletMode.toString())) {
3925                            if (layoutType.hasModeAboutPortletId(portletId)) {
3926                                    return LiferayPortletMode.ABOUT;
3927                            }
3928                            else if (layoutType.hasModeConfigPortletId(portletId)) {
3929                                    return LiferayPortletMode.CONFIG;
3930                            }
3931                            else if (layoutType.hasModeEditPortletId(portletId)) {
3932                                    return PortletMode.EDIT;
3933                            }
3934                            else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
3935                                    return LiferayPortletMode.EDIT_DEFAULTS;
3936                            }
3937                            else if (layoutType.hasModeEditGuestPortletId(portletId)) {
3938                                    return LiferayPortletMode.EDIT_GUEST;
3939                            }
3940                            else if (layoutType.hasModeHelpPortletId(portletId)) {
3941                                    return PortletMode.HELP;
3942                            }
3943                            else if (layoutType.hasModePreviewPortletId(portletId)) {
3944                                    return LiferayPortletMode.PREVIEW;
3945                            }
3946                            else if (layoutType.hasModePrintPortletId(portletId)) {
3947                                    return LiferayPortletMode.PRINT;
3948                            }
3949                            else {
3950                                    return PortletMode.VIEW;
3951                            }
3952                    }
3953                    else {
3954                            boolean updateLayout = false;
3955    
3956                            if (portletMode.equals(LiferayPortletMode.ABOUT) &&
3957                                    !layoutType.hasModeAboutPortletId(portletId)) {
3958    
3959                                    layoutType.addModeAboutPortletId(portletId);
3960    
3961                                    updateLayout = true;
3962                            }
3963                            else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
3964                                             !layoutType.hasModeConfigPortletId(portletId)) {
3965    
3966                                    layoutType.addModeConfigPortletId(portletId);
3967    
3968                                    updateLayout = true;
3969                            }
3970                            else if (portletMode.equals(PortletMode.EDIT) &&
3971                                             !layoutType.hasModeEditPortletId(portletId)) {
3972    
3973                                    layoutType.addModeEditPortletId(portletId);
3974    
3975                                    updateLayout = true;
3976                            }
3977                            else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
3978                                             !layoutType.hasModeEditDefaultsPortletId(portletId)) {
3979    
3980                                    layoutType.addModeEditDefaultsPortletId(portletId);
3981    
3982                                    updateLayout = true;
3983                            }
3984                            else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
3985                                             !layoutType.hasModeEditGuestPortletId(portletId)) {
3986    
3987                                    layoutType.addModeEditGuestPortletId(portletId);
3988    
3989                                    updateLayout = true;
3990                            }
3991                            else if (portletMode.equals(PortletMode.HELP) &&
3992                                             !layoutType.hasModeHelpPortletId(portletId)) {
3993    
3994                                    layoutType.addModeHelpPortletId(portletId);
3995    
3996                                    updateLayout = true;
3997                            }
3998                            else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
3999                                             !layoutType.hasModePreviewPortletId(portletId)) {
4000    
4001                                    layoutType.addModePreviewPortletId(portletId);
4002    
4003                                    updateLayout = true;
4004                            }
4005                            else if (portletMode.equals(LiferayPortletMode.PRINT) &&
4006                                             !layoutType.hasModePrintPortletId(portletId)) {
4007    
4008                                    layoutType.addModePrintPortletId(portletId);
4009    
4010                                    updateLayout = true;
4011                            }
4012                            else if (portletMode.equals(PortletMode.VIEW) &&
4013                                             !layoutType.hasModeViewPortletId(portletId)) {
4014    
4015                                    layoutType.removeModesPortletId(portletId);
4016    
4017                                    updateLayout = true;
4018                            }
4019    
4020                            if (updateLayout) {
4021                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
4022    
4023                                    if (layoutClone != null) {
4024                                            layoutClone.update(
4025                                                    request, layout.getPlid(), layout.getTypeSettings());
4026                                    }
4027                            }
4028    
4029                            return portletMode;
4030                    }
4031            }
4032    
4033            public WindowState updateWindowState(
4034                    String portletId, User user, Layout layout, WindowState windowState,
4035                    HttpServletRequest request) {
4036    
4037                    LayoutTypePortlet layoutType =
4038                            (LayoutTypePortlet)layout.getLayoutType();
4039    
4040                    if ((windowState == null) ||
4041                            (Validator.isNull(windowState.toString()))) {
4042    
4043                            if (layoutType.hasStateMaxPortletId(portletId)) {
4044                                    windowState = WindowState.MAXIMIZED;
4045                            }
4046                            else if (layoutType.hasStateMinPortletId(portletId)) {
4047                                    windowState = WindowState.MINIMIZED;
4048                            }
4049                            else {
4050                                    windowState = WindowState.NORMAL;
4051                            }
4052                    }
4053                    else {
4054                            boolean updateLayout = false;
4055    
4056                            if (windowState.equals(WindowState.MAXIMIZED) &&
4057                                    !layoutType.hasStateMaxPortletId(portletId)) {
4058    
4059                                    layoutType.addStateMaxPortletId(portletId);
4060    
4061                                    if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
4062                                            updateLayout = true;
4063                                    }
4064                            }
4065                            else if (windowState.equals(WindowState.MINIMIZED) &&
4066                                             !layoutType.hasStateMinPortletId(portletId)) {
4067    
4068                                    layoutType.addStateMinPortletId(portletId);
4069    
4070                                    updateLayout = true;
4071                            }
4072                            else if (windowState.equals(WindowState.NORMAL) &&
4073                                             !layoutType.hasStateNormalPortletId(portletId)) {
4074    
4075                                    layoutType.removeStatesPortletId(portletId);
4076    
4077                                    updateLayout = true;
4078                            }
4079    
4080                            if (portletId.equals(PortletKeys.LAYOUT_MANAGEMENT) ||
4081                                    portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
4082    
4083                                    updateLayout = false;
4084                            }
4085    
4086                            if (updateLayout) {
4087                                    LayoutClone layoutClone = LayoutCloneFactory.getInstance();
4088    
4089                                    if (layoutClone != null) {
4090                                            layoutClone.update(
4091                                                    request, layout.getPlid(), layout.getTypeSettings());
4092                                    }
4093                            }
4094                    }
4095    
4096                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4097                            WebKeys.THEME_DISPLAY);
4098    
4099                    themeDisplay.setStateExclusive(
4100                            windowState.equals(LiferayWindowState.EXCLUSIVE));
4101                    themeDisplay.setStateMaximized(
4102                            windowState.equals(WindowState.MAXIMIZED));
4103                    themeDisplay.setStatePopUp(
4104                            windowState.equals(LiferayWindowState.POP_UP));
4105    
4106                    if (themeDisplay.isStateMaximized() &&
4107                            themeDisplay.isShowAddContentIcon()) {
4108    
4109                            themeDisplay.setShowAddContentIcon(false);
4110                    }
4111                    else if (!themeDisplay.isStateMaximized() &&
4112                                     !themeDisplay.isShowAddContentIcon() &&
4113                                     themeDisplay.isShowAddContentIconPermission()) {
4114    
4115                            themeDisplay.setShowAddContentIcon(true);
4116                    }
4117    
4118                    request.setAttribute(WebKeys.WINDOW_STATE, windowState);
4119    
4120                    return windowState;
4121            }
4122    
4123            protected void addDefaultResource(
4124                            ThemeDisplay themeDisplay, Layout layout, Portlet portlet,
4125                            boolean portletActions)
4126                    throws PortalException, SystemException {
4127    
4128                    String rootPortletId = portlet.getRootPortletId();
4129    
4130                    String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
4131                            layout.getPlid(), portlet.getPortletId());
4132    
4133                    String name = null;
4134                    String primaryKey = null;
4135    
4136                    if (portletActions) {
4137                            name = rootPortletId;
4138                            primaryKey = portletPrimaryKey;
4139                    }
4140                    else {
4141                            name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
4142                            primaryKey = String.valueOf(layout.getGroupId());
4143                    }
4144    
4145                    if (Validator.isNull(name)) {
4146                            return;
4147                    }
4148    
4149                    try {
4150                            if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
4151                                    int count =
4152                                            ResourcePermissionLocalServiceUtil.
4153                                                    getResourcePermissionsCount(
4154                                                            themeDisplay.getCompanyId(), name,
4155                                                            ResourceConstants.SCOPE_INDIVIDUAL,
4156                                                            primaryKey);
4157    
4158                                    if (count == 0) {
4159                                            throw new NoSuchResourceException();
4160                                    }
4161                            }
4162                            else if (!portlet.isUndeployedPortlet()) {
4163                                    ResourceLocalServiceUtil.getResource(
4164                                            themeDisplay.getCompanyId(), name,
4165                                            ResourceConstants.SCOPE_INDIVIDUAL, primaryKey);
4166                            }
4167                    }
4168                    catch (NoSuchResourceException nsre) {
4169                            ResourceLocalServiceUtil.addResources(
4170                                    themeDisplay.getCompanyId(), layout.getGroupId(), 0, name,
4171                                    primaryKey, portletActions, true, true);
4172                    }
4173            }
4174    
4175            protected List<Portlet> filterControlPanelPortlets(
4176                    Set<Portlet> portlets, String category, ThemeDisplay themeDisplay) {
4177    
4178                    Group group = themeDisplay.getScopeGroup();
4179    
4180                    List<Portlet> filteredPortlets = new ArrayList<Portlet>();
4181    
4182                    if (category.equals(PortletCategoryKeys.CONTENT) && group.isLayout()) {
4183                            for (Portlet portlet : portlets) {
4184                                    if (portlet.isScopeable()) {
4185                                            filteredPortlets.add(portlet);
4186                                    }
4187                            }
4188                    }
4189                    else {
4190                            filteredPortlets.addAll(portlets);
4191                    }
4192    
4193                    Iterator<Portlet> itr = filteredPortlets.iterator();
4194    
4195                    while (itr.hasNext()) {
4196                            Portlet portlet = itr.next();
4197    
4198                            try {
4199                                    ControlPanelEntry controlPanelEntry =
4200                                            portlet.getControlPanelEntryInstance();
4201    
4202                                    if (controlPanelEntry == null) {
4203                                            controlPanelEntry =
4204                                                    DefaultControlPanelEntryFactory.getInstance();
4205                                    }
4206    
4207                                    if (!controlPanelEntry.isVisible(
4208                                                    portlet, category, themeDisplay)) {
4209    
4210                                            itr.remove();
4211                                    }
4212                            }
4213                            catch (Exception e) {
4214                                    _log.error(e, e);
4215    
4216                                    itr.remove();
4217                            }
4218                    }
4219    
4220                    return filteredPortlets;
4221            }
4222    
4223            protected long getDoAsUserId(
4224                            HttpServletRequest request, String doAsUserIdString,
4225                            boolean alwaysAllowDoAsUser)
4226                    throws Exception {
4227    
4228                    if (Validator.isNull(doAsUserIdString)) {
4229                            return 0;
4230                    }
4231    
4232                    long doAsUserId = 0;
4233    
4234                    try {
4235                            Company company = getCompany(request);
4236    
4237                            doAsUserId = GetterUtil.getLong(
4238                                    Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
4239                    }
4240                    catch (Exception e) {
4241                            if (_log.isWarnEnabled()) {
4242                                    _log.warn(
4243                                            "Unable to impersonate " + doAsUserIdString +
4244                                                    " because the string cannot be decrypted",
4245                                            e);
4246                            }
4247    
4248                            return 0;
4249                    }
4250    
4251                    if (_log.isDebugEnabled()) {
4252                            if (alwaysAllowDoAsUser) {
4253                                    _log.debug(
4254                                            "doAsUserId path or Struts action is always allowed");
4255                            }
4256                            else {
4257                                    _log.debug(
4258                                            "doAsUserId path is Struts action not always allowed");
4259                            }
4260                    }
4261    
4262                    if (alwaysAllowDoAsUser) {
4263                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
4264    
4265                            return doAsUserId;
4266                    }
4267    
4268                    HttpSession session = request.getSession();
4269    
4270                    Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
4271    
4272                    if (realUserIdObj == null) {
4273                            return 0;
4274                    }
4275    
4276                    User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
4277    
4278                    long[] organizationIds = doAsUser.getOrganizationIds();
4279    
4280                    User realUser = UserLocalServiceUtil.getUserById(
4281                            realUserIdObj.longValue());
4282                    boolean checkGuest = true;
4283    
4284                    PermissionChecker permissionChecker =
4285                            PermissionCheckerFactoryUtil.create(realUser, checkGuest);
4286    
4287                    if (doAsUser.isDefaultUser() ||
4288                            UserPermissionUtil.contains(
4289                                    permissionChecker, doAsUserId, organizationIds,
4290                                    ActionKeys.IMPERSONATE)) {
4291    
4292                            request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
4293    
4294                            return doAsUserId;
4295                    }
4296                    else {
4297                            _log.error(
4298                                    "User " + realUserIdObj + " does not have the permission " +
4299                                            "to impersonate " + doAsUserId);
4300    
4301                            return 0;
4302                    }
4303            }
4304    
4305            protected void notifyPortalPortEventListeners(int portalPort) {
4306                    for (PortalPortEventListener portalPortEventListener :
4307                                    _portalPortEventListeners) {
4308    
4309                            portalPortEventListener.portalPortConfigured(portalPort);
4310                    }
4311            }
4312    
4313            private long _getPlidFromPortletId(
4314                            long groupId, boolean privateLayout, String portletId)
4315                    throws PortalException, SystemException {
4316    
4317                    long scopeGroupId = groupId;
4318    
4319                    try {
4320                            Group group = GroupLocalServiceUtil.getGroup(groupId);
4321    
4322                            if (group.isLayout()) {
4323                                    Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
4324                                            group.getClassPK());
4325    
4326                                    groupId = scopeLayout.getGroupId();
4327                            }
4328                    }
4329                    catch (Exception e) {
4330                    }
4331    
4332                    long plid = LayoutConstants.DEFAULT_PLID;
4333    
4334                    List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
4335                            groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
4336    
4337                    for (Layout layout : layouts) {
4338                            LayoutTypePortlet layoutTypePortlet =
4339                                    (LayoutTypePortlet)layout.getLayoutType();
4340    
4341                            if (layoutTypePortlet.hasPortletId(portletId)) {
4342                                    if (getScopeGroupId(layout, portletId) == scopeGroupId) {
4343                                            plid = layout.getPlid();
4344    
4345                                            break;
4346                                    }
4347                            }
4348                    }
4349    
4350                    return plid;
4351            }
4352    
4353            private String _getPortletParam(HttpServletRequest request, String name) {
4354                    String value = null;
4355    
4356                    int valueCount = 0;
4357    
4358                    Enumeration<String> enu = request.getParameterNames();
4359    
4360                    while (enu.hasMoreElements()) {
4361                            String curName = enu.nextElement();
4362    
4363                            int pos = curName.indexOf(StringPool.UNDERLINE + name);
4364    
4365                            if (pos != -1) {
4366                                    valueCount++;
4367    
4368                                    // There should never be more than one value
4369    
4370                                    if (valueCount > 1) {
4371                                            return StringPool.BLANK;
4372                                    }
4373    
4374                                    String curValue = ParamUtil.getString(request, curName);
4375    
4376                                    if (Validator.isNotNull(curValue)) {
4377    
4378                                            // The Struts action must be for the correct portlet
4379    
4380                                            String portletId1 = curName.substring(1, pos);
4381                                            String portletId2 = ParamUtil.getString(request, "p_p_id");
4382    
4383                                            if (portletId1.equals(portletId2)) {
4384                                                    value = curValue;
4385                                            }
4386                                    }
4387                            }
4388                    }
4389    
4390                    if (value == null) {
4391                            value = StringPool.BLANK;
4392                    }
4393    
4394                    return value;
4395            }
4396    
4397            private String _getServletURL(
4398                            Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
4399                    throws PortalException, SystemException {
4400    
4401                    String layoutURL = getLayoutURL(themeDisplay);
4402    
4403                    Layout layout = themeDisplay.getLayout();
4404    
4405                    StringBundler sb = new StringBundler();
4406    
4407                    if (HttpUtil.hasDomain(layoutURL)) {
4408                            String protocol = HttpUtil.getProtocol(layoutURL);
4409                            String domain = HttpUtil.getDomain(layoutURL);
4410                            HttpUtil.removeDomain(layoutURL);
4411    
4412                            sb.append(protocol);
4413                            sb.append(Http.PROTOCOL_DELIMITER);
4414                            sb.append(domain);
4415    
4416                            if (Validator.isNotNull(_pathContext)) {
4417                                    sb.append(_pathContext);
4418                            }
4419    
4420                            if (themeDisplay.isI18n()) {
4421                                    sb.append(themeDisplay.getI18nPath());
4422                            }
4423    
4424                            sb.append(servletPath);
4425                            sb.append(layout.getFriendlyURL());
4426                    }
4427                    else {
4428                            sb.append(themeDisplay.getPortalURL());
4429    
4430                            if (Validator.isNotNull(_pathContext)) {
4431                                    sb.append(_pathContext);
4432                            }
4433    
4434                            if (themeDisplay.isI18n()) {
4435                                    sb.append(themeDisplay.getI18nPath());
4436                            }
4437    
4438                            sb.append(servletPath);
4439    
4440                            Group group = layout.getGroup();
4441    
4442                            if (layout.isPrivateLayout()) {
4443                                    if (group.isUser()) {
4444                                            sb.append(_PRIVATE_USER_SERVLET_MAPPING);
4445                                    }
4446                                    else {
4447                                            sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
4448                                    }
4449                            }
4450                            else {
4451                                    sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
4452                            }
4453    
4454                            sb.append(group.getFriendlyURL());
4455                            sb.append(layout.getFriendlyURL());
4456                    }
4457    
4458                    sb.append(FRIENDLY_URL_SEPARATOR);
4459    
4460                    FriendlyURLMapper friendlyURLMapper =
4461                            portlet.getFriendlyURLMapperInstance();
4462    
4463                    if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
4464                            sb.append(friendlyURLMapper.getMapping());
4465                    }
4466                    else {
4467                            sb.append(portlet.getPortletId());
4468                    }
4469    
4470                    return sb.toString();
4471            }
4472    
4473            private void _initCustomSQL() {
4474                    _customSqlClassNames = new String[] {
4475                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
4476                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
4477                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
4478                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
4479                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
4480                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
4481                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
4482                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
4483                                    "BOOKMARKSENTRY$]",
4484                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
4485                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
4486                                    "DLFILEENTRY$]",
4487                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
4488                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4489                                    "MBMESSAGE$]",
4490                            "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
4491                            "[$FALSE$]",
4492                            "[$TRUE$]"
4493                    };
4494    
4495                    DB db = DBFactoryUtil.getDB();
4496    
4497                    _customSqlClassNameIds = new String[] {
4498                            String.valueOf(PortalUtil.getClassNameId(Group.class)),
4499                            String.valueOf(PortalUtil.getClassNameId(Layout.class)),
4500                            String.valueOf(PortalUtil.getClassNameId(Organization.class)),
4501                            String.valueOf(PortalUtil.getClassNameId(Role.class)),
4502                            String.valueOf(PortalUtil.getClassNameId(User.class)),
4503                            String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
4504                            String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
4505                            String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
4506                            String.valueOf(PortalUtil.getClassNameId(CalEvent.class)),
4507                            String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
4508                            String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
4509                            String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
4510                            String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
4511                            db.getTemplateFalse(),
4512                            db.getTemplateTrue()
4513                    };
4514            }
4515    
4516            private static final String _J_SECURITY_CHECK = "j_security_check";
4517    
4518            private static final String _JSESSIONID = ";jsessionid=";
4519    
4520            private static final String _LOCALHOST = "localhost";
4521    
4522            private static final String  _PRIVATE_GROUP_SERVLET_MAPPING =
4523                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
4524    
4525            private static final String _PRIVATE_USER_SERVLET_MAPPING =
4526                    PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
4527    
4528            private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
4529                    PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
4530    
4531            private static final Date _UP_TIME = new Date();
4532    
4533            private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
4534    
4535            private static Log _logImageServlet = LogFactoryUtil.getLog(
4536                    ImageServlet.class);
4537    
4538            private String[] _allSystemCommunityRoles;
4539            private String[] _allSystemGroups;
4540            private String[] _allSystemOrganizationRoles;
4541            private String[] _allSystemRoles;
4542            private Pattern _bannedRresourceIdPattern = Pattern.compile(
4543                    PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP);
4544            private String _cdnHostHttp;
4545            private String _cdnHostHttps;
4546            private String _computerAddress;
4547            private String _computerName;
4548            private String[] _customSqlClassNameIds;
4549            private String[] _customSqlClassNames;
4550            private String _globalLibDir;
4551            private String _pathContext;
4552            private String _pathFriendlyURLPrivateGroup;
4553            private String _pathFriendlyURLPrivateUser;
4554            private String _pathFriendlyURLPublic;
4555            private String _pathImage;
4556            private String _pathMain;
4557            private Map<String, Long> _plidToPortletIdCache =
4558                    new ConcurrentHashMap<String, Long>();
4559            private String _portalLibDir;
4560            private volatile int _portalPort = -1;
4561            private List<PortalPortEventListener> _portalPortEventListeners =
4562                    new ArrayList<PortalPortEventListener>();
4563            private Lock _portalPortLock = new ReentrantLock();
4564            private String _portalWebDir;
4565            private Set<String> _portletAddDefaultResourceCheckWhitelist;
4566            private Set<String> _portletAddDefaultResourceCheckWhitelistActions;
4567            private Set<String> _reservedParams;
4568            private String[] _sortedSystemCommunityRoles;
4569            private String[] _sortedSystemGroups;
4570            private String[] _sortedSystemOrganizationRoles;
4571            private String[] _sortedSystemRoles;
4572    
4573    }