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