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