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