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