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