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