001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.expando.kernel.model.ExpandoBridge;
020    import com.liferay.portal.kernel.exception.PortalException;
021    import com.liferay.portal.kernel.model.BaseModel;
022    import com.liferay.portal.kernel.model.Company;
023    import com.liferay.portal.kernel.model.Group;
024    import com.liferay.portal.kernel.model.Layout;
025    import com.liferay.portal.kernel.model.LayoutFriendlyURLComposite;
026    import com.liferay.portal.kernel.model.LayoutQueryStringComposite;
027    import com.liferay.portal.kernel.model.LayoutSet;
028    import com.liferay.portal.kernel.model.LayoutTypePortlet;
029    import com.liferay.portal.kernel.model.Portlet;
030    import com.liferay.portal.kernel.model.ResourcePermission;
031    import com.liferay.portal.kernel.model.User;
032    import com.liferay.portal.kernel.portlet.InvokerPortlet;
033    import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
034    import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
035    import com.liferay.portal.kernel.portlet.PortletInstanceFactoryUtil;
036    import com.liferay.portal.kernel.security.pacl.permission.PortalRuntimePermission;
037    import com.liferay.portal.kernel.service.PortletLocalServiceUtil;
038    import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
039    import com.liferay.portal.kernel.theme.PortletDisplay;
040    import com.liferay.portal.kernel.theme.ThemeDisplay;
041    import com.liferay.portal.kernel.upload.UploadPortletRequest;
042    import com.liferay.portal.kernel.upload.UploadServletRequest;
043    
044    import java.io.IOException;
045    import java.io.Serializable;
046    
047    import java.net.InetAddress;
048    
049    import java.util.Date;
050    import java.util.List;
051    import java.util.Locale;
052    import java.util.Map;
053    import java.util.Properties;
054    import java.util.ResourceBundle;
055    import java.util.Set;
056    import java.util.TimeZone;
057    
058    import javax.portlet.ActionRequest;
059    import javax.portlet.ActionResponse;
060    import javax.portlet.PortletConfig;
061    import javax.portlet.PortletException;
062    import javax.portlet.PortletMode;
063    import javax.portlet.PortletPreferences;
064    import javax.portlet.PortletRequest;
065    import javax.portlet.PortletResponse;
066    import javax.portlet.PortletURL;
067    import javax.portlet.PreferencesValidator;
068    import javax.portlet.RenderRequest;
069    import javax.portlet.ResourceRequest;
070    import javax.portlet.ResourceResponse;
071    import javax.portlet.ValidatorException;
072    import javax.portlet.WindowState;
073    
074    import javax.servlet.ServletContext;
075    import javax.servlet.ServletException;
076    import javax.servlet.http.HttpServletRequest;
077    import javax.servlet.http.HttpServletResponse;
078    import javax.servlet.http.HttpSession;
079    
080    /**
081     * @author Brian Wing Shun Chan
082     * @author Eduardo Lundgren
083     * @author Juan Fernández
084     */
085    @ProviderType
086    public class PortalUtil {
087    
088            /**
089             * Appends the description to the current meta description of the page in
090             * the request.
091             *
092             * @param description the description to append to the current meta
093             *        description
094             * @param request the servlet request for the page
095             */
096            public static void addPageDescription(
097                    String description, HttpServletRequest request) {
098    
099                    getPortal().addPageDescription(description, request);
100            }
101    
102            /**
103             * Appends the keywords to the current meta keywords of the page in the
104             * request.
105             *
106             * @param keywords the keywords to add to the current meta keywords
107             *        (comma-separated)
108             * @param request the servlet request for the page
109             */
110            public static void addPageKeywords(
111                    String keywords, HttpServletRequest request) {
112    
113                    getPortal().addPageKeywords(keywords, request);
114            }
115    
116            /**
117             * Appends the subtitle to the current subtitle of the page in the request.
118             *
119             * @param subtitle the subtitle to append to the current subtitle
120             * @param request the servlet request for the page
121             */
122            public static void addPageSubtitle(
123                    String subtitle, HttpServletRequest request) {
124    
125                    getPortal().addPageSubtitle(subtitle, request);
126            }
127    
128            /**
129             * Appends the title to the current title of the page in the request.
130             *
131             * @param title the title to append to the current title
132             * @param request the servlet request for the page
133             */
134            public static void addPageTitle(String title, HttpServletRequest request) {
135                    getPortal().addPageTitle(title, request);
136            }
137    
138            public static boolean addPortalInetSocketAddressEventListener(
139                    PortalInetSocketAddressEventListener
140                            portalInetSocketAddressEventListener) {
141    
142                    return getPortal().addPortalInetSocketAddressEventListener(
143                            portalInetSocketAddressEventListener);
144            }
145    
146            /**
147             * Adds the portal port event listener to the portal. The listener is
148             * notified whenever the portal port is set.
149             *
150             * @param      portalPortEventListener the portal port event listener to add
151             * @deprecated As of 7.0.0, replaced by {@link
152             *             #addPortalInetSocketAddressEventListener(
153             *             PortalInetSocketAddressEventListener)}
154             */
155            @Deprecated
156            public static void addPortalPortEventListener(
157                    PortalPortEventListener portalPortEventListener) {
158    
159                    getPortal().addPortalPortEventListener(portalPortEventListener);
160            }
161    
162            /**
163             * Adds an entry to the portlet breadcrumbs for the page in the request.
164             *
165             * @param request the servlet request for the page
166             * @param title the title of the new breadcrumb entry
167             * @param url the URL of the new breadcrumb entry
168             */
169            public static void addPortletBreadcrumbEntry(
170                    HttpServletRequest request, String title, String url) {
171    
172                    getPortal().addPortletBreadcrumbEntry(request, title, url);
173            }
174    
175            /**
176             * Adds an entry to the portlet breadcrumbs for the page in the request.
177             *
178             * @param request the servlet request for the page
179             * @param title the title of the new breadcrumb entry
180             * @param url the URL of the new breadcrumb entry
181             * @param data the HTML5 data parameters of the new breadcrumb entry
182             */
183            public static void addPortletBreadcrumbEntry(
184                    HttpServletRequest request, String title, String url,
185                    Map<String, Object> data) {
186    
187                    getPortal().addPortletBreadcrumbEntry(request, title, url, data);
188            }
189    
190            /**
191             * Adds the default resource permissions for the portlet to the page in the
192             * request.
193             *
194             * @param request the servlet request for the page
195             * @param portlet the portlet
196             */
197            public static void addPortletDefaultResource(
198                            HttpServletRequest request, Portlet portlet)
199                    throws PortalException {
200    
201                    getPortal().addPortletDefaultResource(request, portlet);
202            }
203    
204            public static void addPortletDefaultResource(
205                            long companyId, Layout layout, Portlet portlet)
206                    throws PortalException {
207    
208                    getPortal().addPortletDefaultResource(companyId, layout, portlet);
209            }
210    
211            /**
212             * Adds the preserved parameters doAsGroupId and refererPlid to the URL,
213             * optionally adding doAsUserId and doAsUserLanguageId as well.
214             *
215             * <p>
216             * Preserved parameters are parameters that should be sent with every
217             * request as the user navigates the portal.
218             * </p>
219             *
220             * @param  themeDisplay the current theme display
221             * @param  layout the current page
222             * @param  url the URL
223             * @param  doAsUser whether to include doAsUserId and doAsLanguageId in the
224             *         URL if they are available. If <code>false</code>, doAsUserId and
225             *         doAsUserLanguageId will never be added.
226             * @return the URL with the preserved parameters added
227             */
228            public static String addPreservedParameters(
229                    ThemeDisplay themeDisplay, Layout layout, String url,
230                    boolean doAsUser) {
231    
232                    return getPortal().addPreservedParameters(
233                            themeDisplay, layout, url, doAsUser);
234            }
235    
236            /**
237             * Adds the preserved parameters doAsUserId, doAsUserLanguageId,
238             * doAsGroupId, and refererPlid to the URL.
239             *
240             * @param  themeDisplay the current theme display
241             * @param  url the URL
242             * @return the URL with the preserved parameters added
243             */
244            public static String addPreservedParameters(
245                    ThemeDisplay themeDisplay, String url) {
246    
247                    return getPortal().addPreservedParameters(themeDisplay, url);
248            }
249    
250            public static void addUserLocaleOptionsMessage(HttpServletRequest request) {
251                    getPortal().addUserLocaleOptionsMessage(request);
252            }
253    
254            /**
255             * Clears the render parameters in the request if the portlet is in the
256             * action phase.
257             *
258             * @param renderRequest the render request
259             */
260            public static void clearRequestParameters(RenderRequest renderRequest) {
261                    getPortal().clearRequestParameters(renderRequest);
262            }
263    
264            /**
265             * Copies the request parameters to the render parameters, unless a
266             * parameter with that name already exists in the render parameters.
267             *
268             * @param actionRequest the request from which to get the request parameters
269             * @param actionResponse the response to receive the render parameters
270             */
271            public static void copyRequestParameters(
272                    ActionRequest actionRequest, ActionResponse actionResponse) {
273    
274                    getPortal().copyRequestParameters(actionRequest, actionResponse);
275            }
276    
277            /**
278             * Escapes the URL for use in a redirect and checks that security settings
279             * allow the URL is allowed for redirects.
280             *
281             * @param  url the URL to escape
282             * @return the escaped URL, or <code>null</code> if the URL is not allowed
283             *         for redirects
284             */
285            public static String escapeRedirect(String url) {
286                    return getPortal().escapeRedirect(url);
287            }
288    
289            /**
290             * Generates a random key to identify the request based on the input string.
291             *
292             * @param  request the servlet request for the page
293             * @param  input the input string
294             * @return the generated key
295             */
296            public static String generateRandomKey(
297                    HttpServletRequest request, String input) {
298    
299                    return getPortal().generateRandomKey(request, input);
300            }
301    
302            public static String getAbsoluteURL(
303                    HttpServletRequest request, String url) {
304    
305                    return getPortal().getAbsoluteURL(request, url);
306            }
307    
308            public static LayoutQueryStringComposite
309                            getActualLayoutQueryStringComposite(
310                                    long groupId, boolean privateLayout, String friendlyURL,
311                                    Map<String, String[]> params,
312                                    Map<String, Object> requestContext)
313                    throws PortalException {
314    
315                    return getPortal().getActualLayoutQueryStringComposite(
316                            groupId, privateLayout, friendlyURL, params, requestContext);
317            }
318    
319            public static String getActualURL(
320                            long groupId, boolean privateLayout, String mainPath,
321                            String friendlyURL, Map<String, String[]> params,
322                            Map<String, Object> requestContext)
323                    throws PortalException {
324    
325                    return getPortal().getActualURL(
326                            groupId, privateLayout, mainPath, friendlyURL, params,
327                            requestContext);
328            }
329    
330            /**
331             * Returns the alternate URL for the requested canonical URL in the given
332             * locale.
333             *
334             * <p>
335             * The alternate URL lets search engines know that an equivalent page is
336             * available for the given locale. For more information, see <a
337             * href="https://support.google.com/webmasters/answer/189077?hl=en">https://support.google.com/webmasters/answer/189077?hl=en</a>.
338             * </p>
339             *
340             * @param  canonicalURL the canonical URL being requested. For more
341             *         information, see {@link #getCanonicalURL}.
342             * @param  themeDisplay the theme display
343             * @param  locale the locale of the alternate URL being generated
344             * @param  layout the page being requested
345             * @return the alternate URL for the requested canonical URL in the given
346             *         locale
347             */
348            public static String getAlternateURL(
349                            String canonicalURL, ThemeDisplay themeDisplay, Locale locale,
350                            Layout layout)
351                    throws PortalException {
352    
353                    return getPortal().getAlternateURL(
354                            canonicalURL, themeDisplay, locale, layout);
355            }
356    
357            public static long[] getAncestorSiteGroupIds(long groupId)
358                    throws PortalException {
359    
360                    return getPortal().getAncestorSiteGroupIds(groupId);
361            }
362    
363            /**
364             * Returns the base model instance for the resource permission.
365             *
366             * @param  resourcePermission the resource permission
367             * @return the base model instance, or <code>null</code> if the resource
368             *         permission does not have a base model instance (such as if it's a
369             *         portlet)
370             */
371            public static BaseModel<?> getBaseModel(
372                            ResourcePermission resourcePermission)
373                    throws PortalException {
374    
375                    return getPortal().getBaseModel(resourcePermission);
376            }
377    
378            /**
379             * Returns the base model instance for the model name and primary key.
380             *
381             * @param  modelName the fully qualified class name of the model
382             * @param  primKey the primary key of the model instance to get
383             * @return the base model instance, or <code>null</code> if the model does
384             *         not have a base model instance (such as if it's a portlet)
385             */
386            public static BaseModel<?> getBaseModel(String modelName, String primKey)
387                    throws PortalException {
388    
389                    return getPortal().getBaseModel(modelName, primKey);
390            }
391    
392            /**
393             * @deprecated As of 7.0.0, replaced by {@link
394             *             com.liferay.portal.kernel.security.auth.http.HttpAuthManagerUtil#getBasicUserId(
395             *             HttpServletRequest)}
396             */
397            @Deprecated
398            public static long getBasicAuthUserId(HttpServletRequest request)
399                    throws PortalException {
400    
401                    return getPortal().getBasicAuthUserId(request);
402            }
403    
404            /**
405             * @deprecated As of 7.0.0, replaced by {@link
406             *             com.liferay.portal.kernel.security.auth.http.HttpAuthManagerUtil#getBasicUserId(
407             *             HttpServletRequest)}
408             */
409            @Deprecated
410            public static long getBasicAuthUserId(
411                            HttpServletRequest request, long companyId)
412                    throws PortalException {
413    
414                    return getPortal().getBasicAuthUserId(request, companyId);
415            }
416    
417            public static List<Group> getBrowsableScopeGroups(
418                            long userId, long companyId, long groupId, String portletId)
419                    throws PortalException {
420    
421                    return getPortal().getBrowsableScopeGroups(
422                            userId, companyId, groupId, portletId);
423            }
424    
425            /**
426             * Returns the canonical URL for the page. The canonical URL is often used
427             * to distinguish a preferred page from its translations.
428             *
429             * <p>
430             * A canonical URL for the page is the preferred URL to specify for a set of
431             * pages with similar or identical content. The canonical URL is used to
432             * inform search engines that several URLs point to the same page. It is
433             * also used to generate the URLs for site maps, the URLs that social
434             * bookmarks publish (Twitter, Facebook links, etc.), and the URLs in sent
435             * email. For more information, see <a
436             * href="https://support.google.com/webmasters/answer/139394?hl=en">https://support.google.com/webmasters/answer/139394?hl=en</a>.
437             * </p>
438             *
439             * @param  completeURL the complete URL of the page
440             * @param  themeDisplay the theme display
441             * @param  layout the page being requested (optionally <code>null</code>).
442             *         If <code>null</code> is specified, the current page is used.
443             * @return the canonical URL for the page
444             */
445            public static String getCanonicalURL(
446                            String completeURL, ThemeDisplay themeDisplay, Layout layout)
447                    throws PortalException {
448    
449                    return getPortal().getCanonicalURL(completeURL, themeDisplay, layout);
450            }
451    
452            /**
453             * Returns the canonical URL of the page, optionally including the page's
454             * friendly URL. The canonical URL is often used to distinguish a preferred
455             * page from its translations.
456             *
457             * <p>
458             * A canonical URL for the page is the preferred URL to specify for a set of
459             * pages with similar or identical content. The canonical URL is used to
460             * inform search engines that several URLs point to the same page. It is
461             * also used to generate the URLs for site maps, the URLs that social
462             * bookmarks publish (Twitter, Facebook links, etc.), and the URLs in sent
463             * email. For more information, see <a
464             * href="https://support.google.com/webmasters/answer/139394?hl=en">https://support.google.com/webmasters/answer/139394?hl=en</a>.
465             * </p>
466             *
467             * @param  completeURL the complete URL of the page
468             * @param  themeDisplay the current theme display
469             * @param  layout the page. If it is <code>null</code>, then it is generated
470             *         for the current page.
471             * @param  forceLayoutFriendlyURL whether to add the page's friendly URL to
472             *         the canonical URL
473             * @return the canonical URL of the page
474             */
475            public static String getCanonicalURL(
476                            String completeURL, ThemeDisplay themeDisplay, Layout layout,
477                            boolean forceLayoutFriendlyURL)
478                    throws PortalException {
479    
480                    return getPortal().getCanonicalURL(
481                            completeURL, themeDisplay, layout, forceLayoutFriendlyURL);
482            }
483    
484            /**
485             * Returns the secure (HTTPS) or insecure (HTTP) content distribution
486             * network (CDN) host address for this portal.
487             *
488             * @param  secure whether to get the secure CDN host address
489             * @return the CDN host address
490             */
491            public static String getCDNHost(boolean secure) {
492                    return getPortal().getCDNHost(secure);
493            }
494    
495            public static String getCDNHost(HttpServletRequest request)
496                    throws PortalException {
497    
498                    return getPortal().getCDNHost(request);
499            }
500    
501            /**
502             * Returns the insecure (HTTP) content distribution network (CDN) host
503             * address
504             *
505             * @param  companyId the company ID of a site
506             * @return the CDN host address
507             */
508            public static String getCDNHostHttp(long companyId) {
509                    return getPortal().getCDNHostHttp(companyId);
510            }
511    
512            /**
513             * Returns the secure (HTTPS) content distribution network (CDN) host
514             * address
515             *
516             * @param  companyId the company ID of a site
517             * @return the CDN host address
518             */
519            public static String getCDNHostHttps(long companyId) {
520                    return getPortal().getCDNHostHttps(companyId);
521            }
522    
523            /**
524             * Returns the fully qualified name of the class from its ID.
525             *
526             * @param  classNameId the ID of the class
527             * @return the fully qualified name of the class
528             */
529            public static String getClassName(long classNameId) {
530                    return getPortal().getClassName(classNameId);
531            }
532    
533            /**
534             * Returns the ID of the class from its class object.
535             *
536             * @param  clazz the class object
537             * @return the ID of the class
538             */
539            public static long getClassNameId(Class<?> clazz) {
540                    return getPortal().getClassNameId(clazz);
541            }
542    
543            /**
544             * Returns the ID of the class from its fully qualified name.
545             *
546             * @param  value the fully qualified name of the class
547             * @return the ID of the class
548             */
549            public static long getClassNameId(String value) {
550                    return getPortal().getClassNameId(value);
551            }
552    
553            public static Company getCompany(HttpServletRequest request)
554                    throws PortalException {
555    
556                    return getPortal().getCompany(request);
557            }
558    
559            public static Company getCompany(PortletRequest portletRequest)
560                    throws PortalException {
561    
562                    return getPortal().getCompany(portletRequest);
563            }
564    
565            public static long getCompanyId(HttpServletRequest request) {
566                    return getPortal().getCompanyId(request);
567            }
568    
569            public static long getCompanyId(PortletRequest portletRequest) {
570                    return getPortal().getCompanyId(portletRequest);
571            }
572    
573            public static long[] getCompanyIds() {
574                    return getPortal().getCompanyIds();
575            }
576    
577            public static Set<String> getComputerAddresses() {
578                    return getPortal().getComputerAddresses();
579            }
580    
581            public static String getComputerName() {
582                    return getPortal().getComputerName();
583            }
584    
585            public static String getControlPanelFullURL(
586                            long scopeGroupId, String ppid, Map<String, String[]> params)
587                    throws PortalException {
588    
589                    return getPortal().getControlPanelFullURL(scopeGroupId, ppid, params);
590            }
591    
592            public static long getControlPanelPlid(long companyId)
593                    throws PortalException {
594    
595                    return getPortal().getControlPanelPlid(companyId);
596            }
597    
598            public static long getControlPanelPlid(PortletRequest portletRequest)
599                    throws PortalException {
600    
601                    return getPortal().getControlPanelPlid(portletRequest);
602            }
603    
604            public static PortletURL getControlPanelPortletURL(
605                    HttpServletRequest request, Group group, String portletId,
606                    long refererGroupId, long refererPlid, String lifecycle) {
607    
608                    return getPortal().getControlPanelPortletURL(
609                            request, group, portletId, refererGroupId, refererPlid, lifecycle);
610            }
611    
612            public static PortletURL getControlPanelPortletURL(
613                    HttpServletRequest request, String portletId, String lifecycle) {
614    
615                    return getPortal().getControlPanelPortletURL(
616                            request, portletId, lifecycle);
617            }
618    
619            public static PortletURL getControlPanelPortletURL(
620                    PortletRequest portletRequest, Group group, String portletId,
621                    long refererGroupId, long refererPlid, String lifecycle) {
622    
623                    return getPortal().getControlPanelPortletURL(
624                            portletRequest, group, portletId, refererGroupId, refererPlid,
625                            lifecycle);
626            }
627    
628            public static PortletURL getControlPanelPortletURL(
629                    PortletRequest portletRequest, String portletId, String lifecycle) {
630    
631                    return getPortal().getControlPanelPortletURL(
632                            portletRequest, portletId, lifecycle);
633            }
634    
635            public static String getCreateAccountURL(
636                            HttpServletRequest request, ThemeDisplay themeDisplay)
637                    throws Exception {
638    
639                    return getPortal().getCreateAccountURL(request, themeDisplay);
640            }
641    
642            public static long[] getCurrentAndAncestorSiteGroupIds(long groupId)
643                    throws PortalException {
644    
645                    return getPortal().getCurrentAndAncestorSiteGroupIds(groupId);
646            }
647    
648            public static long[] getCurrentAndAncestorSiteGroupIds(
649                            long groupId, boolean checkContentSharingWithChildrenEnabled)
650                    throws PortalException {
651    
652                    return getPortal().getCurrentAndAncestorSiteGroupIds(
653                            groupId, checkContentSharingWithChildrenEnabled);
654            }
655    
656            public static long[] getCurrentAndAncestorSiteGroupIds(long[] groupIds)
657                    throws PortalException {
658    
659                    return getPortal().getCurrentAndAncestorSiteGroupIds(groupIds);
660            }
661    
662            public static long[] getCurrentAndAncestorSiteGroupIds(
663                            long[] groupIds, boolean checkContentSharingWithChildrenEnabled)
664                    throws PortalException {
665    
666                    return getPortal().getCurrentAndAncestorSiteGroupIds(
667                            groupIds, checkContentSharingWithChildrenEnabled);
668            }
669    
670            public static List<Group> getCurrentAndAncestorSiteGroups(long groupId)
671                    throws PortalException {
672    
673                    return getPortal().getCurrentAndAncestorSiteGroups(groupId);
674            }
675    
676            public static List<Group> getCurrentAndAncestorSiteGroups(
677                            long groupId, boolean checkContentSharingWithChildrenEnabled)
678                    throws PortalException {
679    
680                    return getPortal().getCurrentAndAncestorSiteGroups(
681                            groupId, checkContentSharingWithChildrenEnabled);
682            }
683    
684            public static List<Group> getCurrentAndAncestorSiteGroups(long[] groupIds)
685                    throws PortalException {
686    
687                    return getPortal().getCurrentAndAncestorSiteGroups(groupIds);
688            }
689    
690            public static List<Group> getCurrentAndAncestorSiteGroups(
691                            long[] groupIds, boolean checkContentSharingWithChildrenEnabled)
692                    throws PortalException {
693    
694                    return getPortal().getCurrentAndAncestorSiteGroups(
695                            groupIds, checkContentSharingWithChildrenEnabled);
696            }
697    
698            public static String getCurrentCompleteURL(HttpServletRequest request) {
699                    return getPortal().getCurrentCompleteURL(request);
700            }
701    
702            public static String getCurrentURL(HttpServletRequest request) {
703                    return getPortal().getCurrentURL(request);
704            }
705    
706            public static String getCurrentURL(PortletRequest portletRequest) {
707                    return getPortal().getCurrentURL(portletRequest);
708            }
709    
710            public static String getCustomSQLFunctionIsNotNull() {
711                    return getPortal().getCustomSQLFunctionIsNotNull();
712            }
713    
714            public static String getCustomSQLFunctionIsNull() {
715                    return getPortal().getCustomSQLFunctionIsNull();
716            }
717    
718            /**
719             * Returns the date object for the specified month, day, and year, or
720             * <code>null</code> if the date is invalid.
721             *
722             * @param  month the month (0-based, meaning 0 for January)
723             * @param  day the day of the month
724             * @param  year the year
725             * @return the date object, or <code>null</code> if the date is invalid
726             */
727            public static Date getDate(int month, int day, int year) {
728                    return getPortal().getDate(month, day, year);
729            }
730    
731            /**
732             * Returns the date object for the specified month, day, and year,
733             * optionally throwing an exception if the date is invalid.
734             *
735             * @param  month the month (0-based, meaning 0 for January)
736             * @param  day the day of the month
737             * @param  year the year
738             * @param  clazz the exception class to throw if the date is invalid. If
739             *         <code>null</code>, no exception will be thrown for an invalid
740             *         date.
741             * @return the date object, or <code>null</code> if the date is invalid and
742             *         no exception to throw was provided
743             */
744            public static Date getDate(
745                            int month, int day, int year,
746                            Class<? extends PortalException> clazz)
747                    throws PortalException {
748    
749                    return getPortal().getDate(month, day, year, clazz);
750            }
751    
752            /**
753             * Returns the date object for the specified month, day, year, hour, and
754             * minute, optionally throwing an exception if the date is invalid.
755             *
756             * @param  month the month (0-based, meaning 0 for January)
757             * @param  day the day of the month
758             * @param  year the year
759             * @param  hour the hour (0-24)
760             * @param  min the minute of the hour
761             * @param  clazz the exception class to throw if the date is invalid. If
762             *         <code>null</code>, no exception will be thrown for an invalid
763             *         date.
764             * @return the date object, or <code>null</code> if the date is invalid and
765             *         no exception to throw was provided
766             */
767            public static Date getDate(
768                            int month, int day, int year, int hour, int min,
769                            Class<? extends PortalException> clazz)
770                    throws PortalException {
771    
772                    return getPortal().getDate(month, day, year, hour, min, clazz);
773            }
774    
775            /**
776             * Returns the date object for the specified month, day, year, hour, minute,
777             * and time zone, optionally throwing an exception if the date is invalid.
778             *
779             * @param  month the month (0-based, meaning 0 for January)
780             * @param  day the day of the month
781             * @param  year the year
782             * @param  hour the hour (0-24)
783             * @param  min the minute of the hour
784             * @param  timeZone the time zone of the date
785             * @param  clazz the exception class to throw if the date is invalid. If
786             *         <code>null</code>, no exception will be thrown for an invalid
787             *         date.
788             * @return the date object, or <code>null</code> if the date is invalid and
789             *         no exception to throw was provided
790             */
791            public static Date getDate(
792                            int month, int day, int year, int hour, int min, TimeZone timeZone,
793                            Class<? extends PortalException> clazz)
794                    throws PortalException {
795    
796                    return getPortal().getDate(
797                            month, day, year, hour, min, timeZone, clazz);
798            }
799    
800            /**
801             * Returns the date object for the specified month, day, year, and time
802             * zone, optionally throwing an exception if the date is invalid.
803             *
804             * @param  month the month (0-based, meaning 0 for January)
805             * @param  day the day of the month
806             * @param  year the year
807             * @param  timeZone the time zone of the date
808             * @param  clazz the exception class to throw if the date is invalid. If
809             *         <code>null</code>, no exception will be thrown for an invalid
810             *         date.
811             * @return the date object, or <code>null</code> if the date is invalid and
812             *         no exception to throw was provided
813             */
814            public static Date getDate(
815                            int month, int day, int year, TimeZone timeZone,
816                            Class<? extends PortalException> clazz)
817                    throws PortalException {
818    
819                    return getPortal().getDate(month, day, year, timeZone, clazz);
820            }
821    
822            public static long getDefaultCompanyId() {
823                    return getPortal().getDefaultCompanyId();
824            }
825    
826            /**
827             * @deprecated As of 7.0.0, replaced by {@link
828             *             com.liferay.portal.kernel.security.auth.http.HttpAuthManagerUtil#getDigestUserId(
829             *             HttpServletRequest)}
830             */
831            @Deprecated
832            public static long getDigestAuthUserId(HttpServletRequest request)
833                    throws PortalException {
834    
835                    return getPortal().getDigestAuthUserId(request);
836            }
837    
838            public static String getEmailFromAddress(
839                    PortletPreferences preferences, long companyId, String defaultValue) {
840    
841                    return getPortal().getEmailFromAddress(
842                            preferences, companyId, defaultValue);
843            }
844    
845            public static String getEmailFromName(
846                    PortletPreferences preferences, long companyId, String defaultValue) {
847    
848                    return getPortal().getEmailFromName(
849                            preferences, companyId, defaultValue);
850            }
851    
852            public static Map<String, Serializable> getExpandoBridgeAttributes(
853                            ExpandoBridge expandoBridge, HttpServletRequest request)
854                    throws PortalException {
855    
856                    return getPortal().getExpandoBridgeAttributes(expandoBridge, request);
857            }
858    
859            public static Map<String, Serializable> getExpandoBridgeAttributes(
860                            ExpandoBridge expandoBridge, PortletRequest portletRequest)
861                    throws PortalException {
862    
863                    return getPortal().getExpandoBridgeAttributes(
864                            expandoBridge, portletRequest);
865            }
866    
867            public static Map<String, Serializable> getExpandoBridgeAttributes(
868                            ExpandoBridge expandoBridge,
869                            UploadPortletRequest uploadPortletRequest)
870                    throws PortalException {
871    
872                    return getPortal().getExpandoBridgeAttributes(
873                            expandoBridge, uploadPortletRequest);
874            }
875    
876            public static Serializable getExpandoValue(
877                            HttpServletRequest request, String name, int type,
878                            String displayType)
879                    throws PortalException {
880    
881                    return getPortal().getExpandoValue(request, name, type, displayType);
882            }
883    
884            public static Serializable getExpandoValue(
885                            PortletRequest portletRequest, String name, int type,
886                            String displayType)
887                    throws PortalException {
888    
889                    return getPortal().getExpandoValue(
890                            portletRequest, name, type, displayType);
891            }
892    
893            public static Serializable getExpandoValue(
894                            UploadPortletRequest uploadPortletRequest, String name, int type,
895                            String displayType)
896                    throws PortalException {
897    
898                    return getPortal().getExpandoValue(
899                            uploadPortletRequest, name, type, displayType);
900            }
901    
902            public static String getFacebookURL(
903                            Portlet portlet, String facebookCanvasPageURL,
904                            ThemeDisplay themeDisplay)
905                    throws PortalException {
906    
907                    return getPortal().getFacebookURL(
908                            portlet, facebookCanvasPageURL, themeDisplay);
909            }
910    
911            public static String getFirstPageLayoutTypes(HttpServletRequest request) {
912                    return getPortal().getFirstPageLayoutTypes(request);
913            }
914    
915            public static String getFullName(
916                    String firstName, String middleName, String lastName) {
917    
918                    return getPortal().getFullName(firstName, middleName, lastName);
919            }
920    
921            public static String getGlobalLibDir() {
922                    return getPortal().getGlobalLibDir();
923            }
924    
925            public static String getGoogleGadgetURL(
926                            Portlet portlet, ThemeDisplay themeDisplay)
927                    throws PortalException {
928    
929                    return getPortal().getGoogleGadgetURL(portlet, themeDisplay);
930            }
931    
932            public static String getGroupFriendlyURL(
933                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
934                    throws PortalException {
935    
936                    return getPortal().getGroupFriendlyURL(layoutSet, themeDisplay);
937            }
938    
939            public static String getGroupFriendlyURL(
940                            LayoutSet layoutSet, ThemeDisplay themeDisplay, Locale locale)
941                    throws PortalException {
942    
943                    return getPortal().getGroupFriendlyURL(layoutSet, themeDisplay, locale);
944            }
945    
946            public static int[] getGroupFriendlyURLIndex(String requestURI) {
947                    return getPortal().getGroupFriendlyURLIndex(requestURI);
948            }
949    
950            public static String[] getGroupPermissions(HttpServletRequest request) {
951                    return getPortal().getGroupPermissions(request);
952            }
953    
954            public static String[] getGroupPermissions(
955                    HttpServletRequest request, String className) {
956    
957                    return getPortal().getGroupPermissions(request, className);
958            }
959    
960            public static String[] getGroupPermissions(PortletRequest portletRequest) {
961                    return getPortal().getGroupPermissions(portletRequest);
962            }
963    
964            public static String[] getGroupPermissions(
965                    PortletRequest portletRequest, String className) {
966    
967                    return getPortal().getGroupPermissions(portletRequest, className);
968            }
969    
970            public static String[] getGuestPermissions(HttpServletRequest request) {
971                    return getPortal().getGuestPermissions(request);
972            }
973    
974            public static String[] getGuestPermissions(
975                    HttpServletRequest request, String className) {
976    
977                    return getPortal().getGuestPermissions(request, className);
978            }
979    
980            public static String[] getGuestPermissions(PortletRequest portletRequest) {
981                    return getPortal().getGuestPermissions(portletRequest);
982            }
983    
984            public static String[] getGuestPermissions(
985                    PortletRequest portletRequest, String className) {
986    
987                    return getPortal().getGuestPermissions(portletRequest, className);
988            }
989    
990            public static String getHomeURL(HttpServletRequest request)
991                    throws PortalException {
992    
993                    return getPortal().getHomeURL(request);
994            }
995    
996            public static String getHost(HttpServletRequest request) {
997                    return getPortal().getHost(request);
998            }
999    
1000            public static String getHost(PortletRequest portletRequest) {
1001                    return getPortal().getHost(portletRequest);
1002            }
1003    
1004            public static HttpServletRequest getHttpServletRequest(
1005                    PortletRequest portletRequest) {
1006    
1007                    return getPortal().getHttpServletRequest(portletRequest);
1008            }
1009    
1010            public static HttpServletResponse getHttpServletResponse(
1011                    PortletResponse portletResponse) {
1012    
1013                    return getPortal().getHttpServletResponse(portletResponse);
1014            }
1015    
1016            public static String getI18nPathLanguageId(
1017                    Locale locale, String defaultI18nPathLanguageId) {
1018    
1019                    return getPortal().getI18nPathLanguageId(
1020                            locale, defaultI18nPathLanguageId);
1021            }
1022    
1023            /**
1024             * @deprecated As of 7.0.0, with no direct replacement
1025             */
1026            @Deprecated
1027            public static String getJournalArticleActualURL(
1028                            long groupId, boolean privateLayout, String mainPath,
1029                            String friendlyURL, Map<String, String[]> params,
1030                            Map<String, Object> requestContext)
1031                    throws PortalException {
1032    
1033                    return getPortal().getJournalArticleActualURL(
1034                            groupId, privateLayout, mainPath, friendlyURL, params,
1035                            requestContext);
1036            }
1037    
1038            /**
1039             * @deprecated As of 7.0.0, with no direct replacement
1040             */
1041            @Deprecated
1042            public static Layout getJournalArticleLayout(
1043                            long groupId, boolean privateLayout, String friendlyURL)
1044                    throws PortalException {
1045    
1046                    return getPortal().getJournalArticleLayout(
1047                            groupId, privateLayout, friendlyURL);
1048            }
1049    
1050            public static String getJsSafePortletId(String portletId) {
1051                    return getPortal().getJsSafePortletId(portletId);
1052            }
1053    
1054            public static String getLayoutActualURL(Layout layout) {
1055                    return getPortal().getLayoutActualURL(layout);
1056            }
1057    
1058            public static String getLayoutActualURL(Layout layout, String mainPath) {
1059                    return getPortal().getLayoutActualURL(layout, mainPath);
1060            }
1061    
1062            public static String getLayoutActualURL(
1063                            long groupId, boolean privateLayout, String mainPath,
1064                            String friendlyURL)
1065                    throws PortalException {
1066    
1067                    return getPortal().getLayoutActualURL(
1068                            groupId, privateLayout, mainPath, friendlyURL);
1069            }
1070    
1071            public static String getLayoutActualURL(
1072                            long groupId, boolean privateLayout, String mainPath,
1073                            String friendlyURL, Map<String, String[]> params,
1074                            Map<String, Object> requestContext)
1075                    throws PortalException {
1076    
1077                    return getPortal().getLayoutActualURL(
1078                            groupId, privateLayout, mainPath, friendlyURL, params,
1079                            requestContext);
1080            }
1081    
1082            public static String getLayoutFriendlyURL(
1083                            Layout layout, ThemeDisplay themeDisplay)
1084                    throws PortalException {
1085    
1086                    return getPortal().getLayoutFriendlyURL(layout, themeDisplay);
1087            }
1088    
1089            public static String getLayoutFriendlyURL(
1090                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1091                    throws PortalException {
1092    
1093                    return getPortal().getLayoutFriendlyURL(layout, themeDisplay, locale);
1094            }
1095    
1096            public static LayoutFriendlyURLComposite getLayoutFriendlyURLComposite(
1097                            long groupId, boolean privateLayout, String friendlyURL,
1098                            Map<String, String[]> params, Map<String, Object> requestContext)
1099                    throws PortalException {
1100    
1101                    return getPortal().getLayoutFriendlyURLComposite(
1102                            groupId, privateLayout, friendlyURL, params, requestContext);
1103            }
1104    
1105            public static String getLayoutFullURL(
1106                            Layout layout, ThemeDisplay themeDisplay)
1107                    throws PortalException {
1108    
1109                    return getPortal().getLayoutFullURL(layout, themeDisplay);
1110            }
1111    
1112            public static String getLayoutFullURL(
1113                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1114                    throws PortalException {
1115    
1116                    return getPortal().getLayoutFullURL(layout, themeDisplay, doAsUser);
1117            }
1118    
1119            public static String getLayoutFullURL(long groupId, String portletId)
1120                    throws PortalException {
1121    
1122                    return getPortal().getLayoutFullURL(groupId, portletId);
1123            }
1124    
1125            public static String getLayoutFullURL(
1126                            long groupId, String portletId, boolean secure)
1127                    throws PortalException {
1128    
1129                    return getPortal().getLayoutFullURL(groupId, portletId, secure);
1130            }
1131    
1132            public static String getLayoutFullURL(ThemeDisplay themeDisplay)
1133                    throws PortalException {
1134    
1135                    return getPortal().getLayoutFullURL(themeDisplay);
1136            }
1137    
1138            public static String getLayoutRelativeURL(
1139                            Layout layout, ThemeDisplay themeDisplay)
1140                    throws PortalException {
1141    
1142                    return getPortal().getLayoutRelativeURL(layout, themeDisplay);
1143            }
1144    
1145            public static String getLayoutRelativeURL(
1146                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1147                    throws PortalException {
1148    
1149                    return getPortal().getLayoutRelativeURL(layout, themeDisplay, doAsUser);
1150            }
1151    
1152            public static String getLayoutSetDisplayURL(
1153                            LayoutSet layoutSet, boolean secureConnection)
1154                    throws PortalException {
1155    
1156                    return getPortal().getLayoutSetDisplayURL(layoutSet, secureConnection);
1157            }
1158    
1159            public static String getLayoutSetFriendlyURL(
1160                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1161                    throws PortalException {
1162    
1163                    return getPortal().getLayoutSetFriendlyURL(layoutSet, themeDisplay);
1164            }
1165    
1166            public static String getLayoutTarget(Layout layout) {
1167                    return getPortal().getLayoutTarget(layout);
1168            }
1169    
1170            public static String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
1171                    throws PortalException {
1172    
1173                    return getPortal().getLayoutURL(layout, themeDisplay);
1174            }
1175    
1176            public static String getLayoutURL(
1177                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1178                    throws PortalException {
1179    
1180                    return getPortal().getLayoutURL(layout, themeDisplay, doAsUser);
1181            }
1182    
1183            public static String getLayoutURL(
1184                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1185                    throws PortalException {
1186    
1187                    return getPortal().getLayoutURL(layout, themeDisplay, locale);
1188            }
1189    
1190            public static String getLayoutURL(ThemeDisplay themeDisplay)
1191                    throws PortalException {
1192    
1193                    return getPortal().getLayoutURL(themeDisplay);
1194            }
1195    
1196            public static LiferayPortletRequest getLiferayPortletRequest(
1197                    PortletRequest portletRequest) {
1198    
1199                    return getPortal().getLiferayPortletRequest(portletRequest);
1200            }
1201    
1202            public static LiferayPortletResponse getLiferayPortletResponse(
1203                    PortletResponse portletResponse) {
1204    
1205                    return getPortal().getLiferayPortletResponse(portletResponse);
1206            }
1207    
1208            public static Locale getLocale(HttpServletRequest request) {
1209                    return getPortal().getLocale(request);
1210            }
1211    
1212            public static Locale getLocale(
1213                    HttpServletRequest request, HttpServletResponse response,
1214                    boolean initialize) {
1215    
1216                    return getPortal().getLocale(request, response, initialize);
1217            }
1218    
1219            public static Locale getLocale(PortletRequest portletRequest) {
1220                    return getPortal().getLocale(portletRequest);
1221            }
1222    
1223            public static String getLocalizedFriendlyURL(
1224                            HttpServletRequest request, Layout layout, Locale locale,
1225                            Locale originalLocale)
1226                    throws Exception {
1227    
1228                    return getPortal().getLocalizedFriendlyURL(
1229                            request, layout, locale, originalLocale);
1230            }
1231    
1232            public static String getMailId(
1233                    String mx, String popPortletPrefix, Object... ids) {
1234    
1235                    return getPortal().getMailId(mx, popPortletPrefix, ids);
1236            }
1237    
1238            public static String getNetvibesURL(
1239                            Portlet portlet, ThemeDisplay themeDisplay)
1240                    throws PortalException {
1241    
1242                    return getPortal().getNetvibesURL(portlet, themeDisplay);
1243            }
1244    
1245            public static String getNewPortletTitle(
1246                    String portletTitle, String oldScopeName, String newScopeName) {
1247    
1248                    return getPortal().getNewPortletTitle(
1249                            portletTitle, oldScopeName, newScopeName);
1250            }
1251    
1252            public static HttpServletRequest getOriginalServletRequest(
1253                    HttpServletRequest request) {
1254    
1255                    return getPortal().getOriginalServletRequest(request);
1256            }
1257    
1258            public static String getPathContext() {
1259                    return getPortal().getPathContext();
1260            }
1261    
1262            public static String getPathContext(HttpServletRequest request) {
1263                    return getPortal().getPathContext(request);
1264            }
1265    
1266            public static String getPathContext(PortletRequest portletRequest) {
1267                    return getPortal().getPathContext(portletRequest);
1268            }
1269    
1270            public static String getPathContext(String contextPath) {
1271                    return getPortal().getPathContext(contextPath);
1272            }
1273    
1274            public static String getPathFriendlyURLPrivateGroup() {
1275                    return getPortal().getPathFriendlyURLPrivateGroup();
1276            }
1277    
1278            public static String getPathFriendlyURLPrivateUser() {
1279                    return getPortal().getPathFriendlyURLPrivateUser();
1280            }
1281    
1282            public static String getPathFriendlyURLPublic() {
1283                    return getPortal().getPathFriendlyURLPublic();
1284            }
1285    
1286            public static String getPathImage() {
1287                    return getPortal().getPathImage();
1288            }
1289    
1290            public static String getPathMain() {
1291                    return getPortal().getPathMain();
1292            }
1293    
1294            public static String getPathModule() {
1295                    return getPortal().getPathModule();
1296            }
1297    
1298            public static String getPathProxy() {
1299                    return getPortal().getPathProxy();
1300            }
1301    
1302            public static long getPlidFromFriendlyURL(
1303                    long companyId, String friendlyURL) {
1304    
1305                    return getPortal().getPlidFromFriendlyURL(companyId, friendlyURL);
1306            }
1307    
1308            public static long getPlidFromPortletId(
1309                            long groupId, boolean privateLayout, String portletId)
1310                    throws PortalException {
1311    
1312                    return getPortal().getPlidFromPortletId(
1313                            groupId, privateLayout, portletId);
1314            }
1315    
1316            public static long getPlidFromPortletId(long groupId, String portletId)
1317                    throws PortalException {
1318    
1319                    return getPortal().getPlidFromPortletId(groupId, portletId);
1320            }
1321    
1322            public static Portal getPortal() {
1323                    PortalRuntimePermission.checkGetBeanProperty(PortalUtil.class);
1324    
1325                    return _portal;
1326            }
1327    
1328            public static PortalInetSocketAddressEventListener[]
1329                    getPortalInetSocketAddressEventListeners() {
1330    
1331                    return getPortal().getPortalInetSocketAddressEventListeners();
1332            }
1333    
1334            public static String getPortalLibDir() {
1335                    return getPortal().getPortalLibDir();
1336            }
1337    
1338            public static InetAddress getPortalLocalInetAddress(boolean secure) {
1339                    return getPortal().getPortalLocalInetAddress(secure);
1340            }
1341    
1342            public static int getPortalLocalPort(boolean secure) {
1343                    return getPortal().getPortalLocalPort(secure);
1344            }
1345    
1346            /**
1347             * @deprecated As of 7.0.0, replaced by {@link
1348             *             #getPortalServerPort(boolean)}
1349             */
1350            @Deprecated
1351            public static int getPortalPort(boolean secure) {
1352                    return getPortal().getPortalPort(secure);
1353            }
1354    
1355            public static Properties getPortalProperties() {
1356                    return getPortal().getPortalProperties();
1357            }
1358    
1359            public static InetAddress getPortalServerInetAddress(boolean secure) {
1360                    return getPortal().getPortalServerInetAddress(secure);
1361            }
1362    
1363            public static int getPortalServerPort(boolean secure) {
1364                    return getPortal().getPortalServerPort(secure);
1365            }
1366    
1367            public static String getPortalURL(HttpServletRequest request) {
1368                    return getPortal().getPortalURL(request);
1369            }
1370    
1371            public static String getPortalURL(
1372                    HttpServletRequest request, boolean secure) {
1373    
1374                    return getPortal().getPortalURL(request, secure);
1375            }
1376    
1377            public static String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
1378                    throws PortalException {
1379    
1380                    return getPortal().getPortalURL(layout, themeDisplay);
1381            }
1382    
1383            public static String getPortalURL(PortletRequest portletRequest) {
1384                    return getPortal().getPortalURL(portletRequest);
1385            }
1386    
1387            public static String getPortalURL(
1388                    PortletRequest portletRequest, boolean secure) {
1389    
1390                    return getPortal().getPortalURL(portletRequest, secure);
1391            }
1392    
1393            public static String getPortalURL(
1394                    String serverName, int serverPort, boolean secure) {
1395    
1396                    return getPortal().getPortalURL(serverName, serverPort, secure);
1397            }
1398    
1399            public static String getPortalURL(ThemeDisplay themeDisplay)
1400                    throws PortalException {
1401    
1402                    return getPortal().getPortalURL(themeDisplay);
1403            }
1404    
1405            public static String getPortalWebDir() {
1406                    return getPortal().getPortalWebDir();
1407            }
1408    
1409            /**
1410             * @deprecated As of 7.0.0, replaced by {@link
1411             *             com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbUtil#getPortletBreadcrumbEntries(
1412             *             HttpServletRequest)}
1413             */
1414            @Deprecated
1415            public static List<BreadcrumbEntry> getPortletBreadcrumbs(
1416                    HttpServletRequest request) {
1417    
1418                    return getPortal().getPortletBreadcrumbs(request);
1419            }
1420    
1421            public static PortletConfig getPortletConfig(
1422                            long companyId, String portletId, ServletContext servletContext)
1423                    throws PortletException {
1424    
1425                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
1426                            companyId, portletId);
1427    
1428                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
1429                            portlet, servletContext);
1430    
1431                    return invokerPortlet.getPortletConfig();
1432            }
1433    
1434            public static String getPortletDescription(
1435                    Portlet portlet, ServletContext servletContext, Locale locale) {
1436    
1437                    return getPortal().getPortletDescription(
1438                            portlet, servletContext, locale);
1439            }
1440    
1441            public static String getPortletDescription(Portlet portlet, User user) {
1442                    return getPortal().getPortletDescription(portlet, user);
1443            }
1444    
1445            public static String getPortletDescription(
1446                    String portletId, Locale locale) {
1447    
1448                    return getPortal().getPortletDescription(portletId, locale);
1449            }
1450    
1451            public static String getPortletDescription(
1452                    String portletId, String languageId) {
1453    
1454                    return getPortal().getPortletDescription(portletId, languageId);
1455            }
1456    
1457            public static String getPortletDescription(String portletId, User user) {
1458                    return getPortal().getPortletDescription(portletId, user);
1459            }
1460    
1461            public static String getPortletId(HttpServletRequest request) {
1462                    return getPortal().getPortletId(request);
1463            }
1464    
1465            public static String getPortletId(PortletRequest portletRequest) {
1466                    return getPortal().getPortletId(portletRequest);
1467            }
1468    
1469            public static String getPortletLongTitle(Portlet portlet, Locale locale) {
1470                    return getPortal().getPortletLongTitle(portlet, locale);
1471            }
1472    
1473            public static String getPortletLongTitle(
1474                    Portlet portlet, ServletContext servletContext, Locale locale) {
1475    
1476                    return getPortal().getPortletLongTitle(portlet, servletContext, locale);
1477            }
1478    
1479            public static String getPortletLongTitle(
1480                    Portlet portlet, String languageId) {
1481    
1482                    return getPortal().getPortletLongTitle(portlet, languageId);
1483            }
1484    
1485            public static String getPortletLongTitle(Portlet portlet, User user) {
1486                    return getPortal().getPortletLongTitle(portlet, user);
1487            }
1488    
1489            public static String getPortletLongTitle(String portletId, Locale locale) {
1490                    return getPortal().getPortletLongTitle(portletId, locale);
1491            }
1492    
1493            public static String getPortletLongTitle(
1494                    String portletId, String languageId) {
1495    
1496                    return getPortal().getPortletLongTitle(portletId, languageId);
1497            }
1498    
1499            public static String getPortletLongTitle(String portletId, User user) {
1500                    return getPortal().getPortletLongTitle(portletId, user);
1501            }
1502    
1503            public static String getPortletNamespace(String portletId) {
1504                    return getPortal().getPortletNamespace(portletId);
1505            }
1506    
1507            public static String getPortletTitle(Portlet portlet, Locale locale) {
1508                    return getPortal().getPortletTitle(portlet, locale);
1509            }
1510    
1511            public static String getPortletTitle(
1512                    Portlet portlet, ServletContext servletContext, Locale locale) {
1513    
1514                    return getPortal().getPortletTitle(portlet, servletContext, locale);
1515            }
1516    
1517            public static String getPortletTitle(Portlet portlet, String languageId) {
1518                    return getPortal().getPortletTitle(portlet, languageId);
1519            }
1520    
1521            public static String getPortletTitle(Portlet portlet, User user) {
1522                    return getPortal().getPortletTitle(portlet, user);
1523            }
1524    
1525            public static String getPortletTitle(PortletRequest portletRequest) {
1526                    return getPortal().getPortletTitle(portletRequest);
1527            }
1528    
1529            public static String getPortletTitle(PortletResponse portletResponse) {
1530                    return getPortal().getPortletTitle(portletResponse);
1531            }
1532    
1533            public static String getPortletTitle(String portletId, Locale locale) {
1534                    return getPortal().getPortletTitle(portletId, locale);
1535            }
1536    
1537            public static String getPortletTitle(
1538                    String portletId, ResourceBundle resourceBundle) {
1539    
1540                    return getPortal().getPortletTitle(portletId, resourceBundle);
1541            }
1542    
1543            public static String getPortletTitle(String portletId, String languageId) {
1544                    return getPortal().getPortletTitle(portletId, languageId);
1545            }
1546    
1547            public static String getPortletTitle(String portletId, User user) {
1548                    return getPortal().getPortletTitle(portletId, user);
1549            }
1550    
1551            public static String getPortletXmlFileName() {
1552                    return getPortal().getPortletXmlFileName();
1553            }
1554    
1555            public static PortletPreferences getPreferences(
1556                    HttpServletRequest request) {
1557    
1558                    return getPortal().getPreferences(request);
1559            }
1560    
1561            public static PreferencesValidator getPreferencesValidator(
1562                    Portlet portlet) {
1563    
1564                    return getPortal().getPreferencesValidator(portlet);
1565            }
1566    
1567            public static String getRelativeHomeURL(HttpServletRequest request)
1568                    throws PortalException {
1569    
1570                    return getPortal().getRelativeHomeURL(request);
1571            }
1572    
1573            public static ResourceBundle getResourceBundle(Locale locale) {
1574                    return getPortal().getResourceBundle(locale);
1575            }
1576    
1577            public static long getScopeGroupId(HttpServletRequest request)
1578                    throws PortalException {
1579    
1580                    return getPortal().getScopeGroupId(request);
1581            }
1582    
1583            public static long getScopeGroupId(
1584                            HttpServletRequest request, String portletId)
1585                    throws PortalException {
1586    
1587                    return getPortal().getScopeGroupId(request, portletId);
1588            }
1589    
1590            public static long getScopeGroupId(
1591                            HttpServletRequest request, String portletId,
1592                            boolean checkStagingGroup)
1593                    throws PortalException {
1594    
1595                    return getPortal().getScopeGroupId(
1596                            request, portletId, checkStagingGroup);
1597            }
1598    
1599            public static long getScopeGroupId(Layout layout) {
1600                    return getPortal().getScopeGroupId(layout);
1601            }
1602    
1603            public static long getScopeGroupId(Layout layout, String portletId) {
1604                    return getPortal().getScopeGroupId(layout, portletId);
1605            }
1606    
1607            public static long getScopeGroupId(long plid) {
1608                    return getPortal().getScopeGroupId(plid);
1609            }
1610    
1611            public static long getScopeGroupId(PortletRequest portletRequest)
1612                    throws PortalException {
1613    
1614                    return getPortal().getScopeGroupId(portletRequest);
1615            }
1616    
1617            public static User getSelectedUser(HttpServletRequest request)
1618                    throws PortalException {
1619    
1620                    return getPortal().getSelectedUser(request);
1621            }
1622    
1623            public static User getSelectedUser(
1624                            HttpServletRequest request, boolean checkPermission)
1625                    throws PortalException {
1626    
1627                    return getPortal().getSelectedUser(request, checkPermission);
1628            }
1629    
1630            public static User getSelectedUser(PortletRequest portletRequest)
1631                    throws PortalException {
1632    
1633                    return getPortal().getSelectedUser(portletRequest);
1634            }
1635    
1636            public static User getSelectedUser(
1637                            PortletRequest portletRequest, boolean checkPermission)
1638                    throws PortalException {
1639    
1640                    return getPortal().getSelectedUser(portletRequest, checkPermission);
1641            }
1642    
1643            public static String getServletContextName() {
1644                    return getPortal().getServletContextName();
1645            }
1646    
1647            public static long[] getSharedContentSiteGroupIds(
1648                            long companyId, long groupId, long userId)
1649                    throws PortalException {
1650    
1651                    return getPortal().getSharedContentSiteGroupIds(
1652                            companyId, groupId, userId);
1653            }
1654    
1655            /**
1656             * @deprecated As of 7.0.0, replaced by {@link
1657             *             #getControlPanelPortletURL(PortletRequest, Group, String,
1658             *             long, String)}
1659             */
1660            @Deprecated
1661            public static PortletURL getSiteAdministrationURL(
1662                    HttpServletRequest request, ThemeDisplay themeDisplay,
1663                    String portletId) {
1664    
1665                    return getPortal().getSiteAdministrationURL(
1666                            request, themeDisplay, portletId);
1667            }
1668    
1669            /**
1670             * @deprecated As of 7.0.0, replaced by {@link
1671             *             #getControlPanelPortletURL(PortletRequest, Group, String,
1672             *             long, String)}
1673             */
1674            @Deprecated
1675            public static PortletURL getSiteAdministrationURL(
1676                    PortletResponse portletResponse, ThemeDisplay themeDisplay,
1677                    String portletName) {
1678    
1679                    return getPortal().getSiteAdministrationURL(
1680                            portletResponse, themeDisplay, portletName);
1681            }
1682    
1683            /**
1684             * @deprecated As of 7.0.0, replaced by {@link
1685             *             #getCurrentAndAncestorSiteGroupIds(long)}
1686             */
1687            @Deprecated
1688            public static long[] getSiteAndCompanyGroupIds(long groupId)
1689                    throws PortalException {
1690    
1691                    return getPortal().getSiteAndCompanyGroupIds(groupId);
1692            }
1693    
1694            /**
1695             * @deprecated As of 7.0.0, replaced by {@link
1696             *             #getCurrentAndAncestorSiteGroupIds(long)}
1697             */
1698            @Deprecated
1699            public static long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
1700                    throws PortalException {
1701    
1702                    return getPortal().getSiteAndCompanyGroupIds(themeDisplay);
1703            }
1704    
1705            public static Locale getSiteDefaultLocale(long groupId)
1706                    throws PortalException {
1707    
1708                    return getPortal().getSiteDefaultLocale(groupId);
1709            }
1710    
1711            public static long getSiteGroupId(long scopeGroupId) {
1712                    return getPortal().getSiteGroupId(scopeGroupId);
1713            }
1714    
1715            public static String getSiteLoginURL(ThemeDisplay themeDisplay)
1716                    throws PortalException {
1717    
1718                    return getPortal().getSiteLoginURL(themeDisplay);
1719            }
1720    
1721            public static String getStaticResourceURL(
1722                    HttpServletRequest request, String uri) {
1723    
1724                    return getPortal().getStaticResourceURL(request, uri);
1725            }
1726    
1727            public static String getStaticResourceURL(
1728                    HttpServletRequest request, String uri, long timestamp) {
1729    
1730                    return getPortal().getStaticResourceURL(request, uri, timestamp);
1731            }
1732    
1733            public static String getStaticResourceURL(
1734                    HttpServletRequest request, String uri, String queryString) {
1735    
1736                    return getPortal().getStaticResourceURL(request, uri, queryString);
1737            }
1738    
1739            public static String getStaticResourceURL(
1740                    HttpServletRequest request, String uri, String queryString,
1741                    long timestamp) {
1742    
1743                    return getPortal().getStaticResourceURL(
1744                            request, uri, queryString, timestamp);
1745            }
1746    
1747            public static String getStrutsAction(HttpServletRequest request) {
1748                    return getPortal().getStrutsAction(request);
1749            }
1750    
1751            public static String[] getSystemGroups() {
1752                    return getPortal().getSystemGroups();
1753            }
1754    
1755            public static String[] getSystemOrganizationRoles() {
1756                    return getPortal().getSystemOrganizationRoles();
1757            }
1758    
1759            public static String[] getSystemRoles() {
1760                    return getPortal().getSystemRoles();
1761            }
1762    
1763            public static String[] getSystemSiteRoles() {
1764                    return getPortal().getSystemSiteRoles();
1765            }
1766    
1767            public static String getUniqueElementId(
1768                    HttpServletRequest request, String namespace, String id) {
1769    
1770                    return getPortal().getUniqueElementId(request, namespace, id);
1771            }
1772    
1773            public static String getUniqueElementId(
1774                    PortletRequest request, String namespace, String id) {
1775    
1776                    return getPortal().getUniqueElementId(request, namespace, id);
1777            }
1778    
1779            public static UploadPortletRequest getUploadPortletRequest(
1780                    PortletRequest portletRequest) {
1781    
1782                    return getPortal().getUploadPortletRequest(portletRequest);
1783            }
1784    
1785            public static UploadServletRequest getUploadServletRequest(
1786                    HttpServletRequest request) {
1787    
1788                    return getPortal().getUploadServletRequest(request);
1789            }
1790    
1791            public static Date getUptime() {
1792                    return getPortal().getUptime();
1793            }
1794    
1795            public static String getURLWithSessionId(String url, String sessionId) {
1796                    return getPortal().getURLWithSessionId(url, sessionId);
1797            }
1798    
1799            public static User getUser(HttpServletRequest request)
1800                    throws PortalException {
1801    
1802                    return getPortal().getUser(request);
1803            }
1804    
1805            public static User getUser(PortletRequest portletRequest)
1806                    throws PortalException {
1807    
1808                    return getPortal().getUser(portletRequest);
1809            }
1810    
1811            public static String getUserEmailAddress(long userId) {
1812                    return getPortal().getUserEmailAddress(userId);
1813            }
1814    
1815            public static long getUserId(HttpServletRequest request) {
1816                    return getPortal().getUserId(request);
1817            }
1818    
1819            public static long getUserId(PortletRequest portletRequest) {
1820                    return getPortal().getUserId(portletRequest);
1821            }
1822    
1823            public static String getUserName(BaseModel<?> baseModel) {
1824                    return getPortal().getUserName(baseModel);
1825            }
1826    
1827            public static String getUserName(long userId, String defaultUserName) {
1828                    return getPortal().getUserName(userId, defaultUserName);
1829            }
1830    
1831            public static String getUserName(
1832                    long userId, String defaultUserName, HttpServletRequest request) {
1833    
1834                    return getPortal().getUserName(userId, defaultUserName, request);
1835            }
1836    
1837            public static String getUserName(
1838                    long userId, String defaultUserName, String userAttribute) {
1839    
1840                    return getPortal().getUserName(userId, defaultUserName, userAttribute);
1841            }
1842    
1843            public static String getUserName(
1844                    long userId, String defaultUserName, String userAttribute,
1845                    HttpServletRequest request) {
1846    
1847                    return getPortal().getUserName(
1848                            userId, defaultUserName, userAttribute, request);
1849            }
1850    
1851            public static String getUserPassword(HttpServletRequest request) {
1852                    return getPortal().getUserPassword(request);
1853            }
1854    
1855            public static String getUserPassword(HttpSession session) {
1856                    return getPortal().getUserPassword(session);
1857            }
1858    
1859            public static String getUserPassword(PortletRequest portletRequest) {
1860                    return getPortal().getUserPassword(portletRequest);
1861            }
1862    
1863            /**
1864             * @deprecated As of 7.0.0, with no direct replacement
1865             */
1866            @Deprecated
1867            public static String getUserValue(
1868                    long userId, String param, String defaultValue) {
1869    
1870                    return getPortal().getUserValue(userId, param, defaultValue);
1871            }
1872    
1873            public static String getValidPortalDomain(long companyId, String domain) {
1874                    return getPortal().getValidPortalDomain(companyId, domain);
1875            }
1876    
1877            public static long getValidUserId(long companyId, long userId)
1878                    throws PortalException {
1879    
1880                    return getPortal().getValidUserId(companyId, userId);
1881            }
1882    
1883            public static String getVirtualHostname(LayoutSet layoutSet) {
1884                    return getPortal().getVirtualHostname(layoutSet);
1885            }
1886    
1887            /**
1888             * @deprecated As of 7.0.0, with no direct replacement
1889             */
1890            @Deprecated
1891            public static String getVirtualLayoutActualURL(
1892                            long groupId, boolean privateLayout, String mainPath,
1893                            String friendlyURL, Map<String, String[]> params,
1894                            Map<String, Object> requestContext)
1895                    throws PortalException {
1896    
1897                    return getPortal().getVirtualLayoutActualURL(
1898                            groupId, privateLayout, mainPath, friendlyURL, params,
1899                            requestContext);
1900            }
1901    
1902            /**
1903             * @deprecated As of 7.0.0, with no direct replacement
1904             */
1905            @Deprecated
1906            public static LayoutFriendlyURLComposite
1907                            getVirtualLayoutFriendlyURLComposite(
1908                                    boolean privateLayout, String friendlyURL,
1909                                    Map<String, String[]> params,
1910                                    Map<String, Object> requestContext)
1911                    throws PortalException {
1912    
1913                    return getPortal().getVirtualLayoutFriendlyURLComposite(
1914                            privateLayout, friendlyURL, params, requestContext);
1915            }
1916    
1917            public static String getWidgetURL(
1918                            Portlet portlet, ThemeDisplay themeDisplay)
1919                    throws PortalException {
1920    
1921                    return getPortal().getWidgetURL(portlet, themeDisplay);
1922            }
1923    
1924            public static void initCustomSQL() {
1925                    getPortal().initCustomSQL();
1926            }
1927    
1928            public static User initUser(HttpServletRequest request) throws Exception {
1929                    return getPortal().initUser(request);
1930            }
1931    
1932            /**
1933             * @deprecated As of 7.0.0, with no direct replacement
1934             */
1935            @Deprecated
1936            public static void invokeTaglibDiscussion(
1937                            PortletConfig portletConfig, ActionRequest actionRequest,
1938                            ActionResponse actionResponse)
1939                    throws Exception {
1940    
1941                    getPortal().invokeTaglibDiscussion(
1942                            portletConfig, actionRequest, actionResponse);
1943            }
1944    
1945            /**
1946             * @deprecated As of 7.0.0, with no direct replacement
1947             */
1948            @Deprecated
1949            public static void invokeTaglibDiscussionPagination(
1950                            PortletConfig portletConfig, ResourceRequest resourceRequest,
1951                            ResourceResponse resourceResponse)
1952                    throws IOException, PortletException {
1953    
1954                    getPortal().invokeTaglibDiscussionPagination(
1955                            portletConfig, resourceRequest, resourceResponse);
1956            }
1957    
1958            public static boolean isCDNDynamicResourcesEnabled(
1959                            HttpServletRequest request)
1960                    throws PortalException {
1961    
1962                    return getPortal().isCDNDynamicResourcesEnabled(request);
1963            }
1964    
1965            public static boolean isCDNDynamicResourcesEnabled(long companyId) {
1966                    return getPortal().isCDNDynamicResourcesEnabled(companyId);
1967            }
1968    
1969            public static boolean isCompanyAdmin(User user) throws Exception {
1970                    return getPortal().isCompanyAdmin(user);
1971            }
1972    
1973            public static boolean isCompanyControlPanelPortlet(
1974                            String portletId, String category, ThemeDisplay themeDisplay)
1975                    throws PortalException {
1976    
1977                    return getPortal().isCompanyControlPanelPortlet(
1978                            portletId, category, themeDisplay);
1979            }
1980    
1981            public static boolean isCompanyControlPanelPortlet(
1982                            String portletId, ThemeDisplay themeDisplay)
1983                    throws PortalException {
1984    
1985                    return getPortal().isCompanyControlPanelPortlet(
1986                            portletId, themeDisplay);
1987            }
1988    
1989            public static boolean isControlPanelPortlet(
1990                    String portletId, String category, ThemeDisplay themeDisplay) {
1991    
1992                    return getPortal().isControlPanelPortlet(
1993                            portletId, category, themeDisplay);
1994            }
1995    
1996            public static boolean isControlPanelPortlet(
1997                    String portletId, ThemeDisplay themeDisplay) {
1998    
1999                    return getPortal().isControlPanelPortlet(portletId, themeDisplay);
2000            }
2001    
2002            public static boolean isGroupAdmin(User user, long groupId)
2003                    throws Exception {
2004    
2005                    return getPortal().isGroupAdmin(user, groupId);
2006            }
2007    
2008            public static boolean isGroupFriendlyURL(
2009                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
2010    
2011                    return getPortal().isGroupFriendlyURL(
2012                            fullURL, groupFriendlyURL, layoutFriendlyURL);
2013            }
2014    
2015            public static boolean isGroupOwner(User user, long groupId)
2016                    throws Exception {
2017    
2018                    return getPortal().isGroupOwner(user, groupId);
2019            }
2020    
2021            public static boolean isLayoutDescendant(Layout layout, long layoutId)
2022                    throws PortalException {
2023    
2024                    return getPortal().isLayoutDescendant(layout, layoutId);
2025            }
2026    
2027            public static boolean isLayoutSitemapable(Layout layout) {
2028                    return getPortal().isLayoutSitemapable(layout);
2029            }
2030    
2031            public static boolean isLoginRedirectRequired(HttpServletRequest request) {
2032                    return getPortal().isLoginRedirectRequired(request);
2033            }
2034    
2035            public static boolean isMethodGet(PortletRequest portletRequest) {
2036                    return getPortal().isMethodGet(portletRequest);
2037            }
2038    
2039            public static boolean isMethodPost(PortletRequest portletRequest) {
2040                    return getPortal().isMethodPost(portletRequest);
2041            }
2042    
2043            public static boolean isMultipartRequest(HttpServletRequest request) {
2044                    return getPortal().isMultipartRequest(request);
2045            }
2046    
2047            public static boolean isOmniadmin(long userId) {
2048                    return getPortal().isOmniadmin(userId);
2049            }
2050    
2051            public static boolean isOmniadmin(User user) {
2052                    return getPortal().isOmniadmin(user);
2053            }
2054    
2055            public static boolean isReservedParameter(String name) {
2056                    return getPortal().isReservedParameter(name);
2057            }
2058    
2059            public static boolean isRightToLeft(HttpServletRequest request) {
2060                    return getPortal().isRightToLeft(request);
2061            }
2062    
2063            public static boolean isRSSFeedsEnabled() {
2064                    return getPortal().isRSSFeedsEnabled();
2065            }
2066    
2067            public static boolean isSecure(HttpServletRequest request) {
2068                    return getPortal().isSecure(request);
2069            }
2070    
2071            public static boolean isSkipPortletContentProcesssing(
2072                            Group group, HttpServletRequest htpServletRequest,
2073                            LayoutTypePortlet layoutTypePortlet, PortletDisplay portletDisplay,
2074                            String portletName)
2075                    throws Exception {
2076    
2077                    return getPortal().isSkipPortletContentProcessing(
2078                            group, htpServletRequest, layoutTypePortlet, portletDisplay,
2079                            portletName);
2080            }
2081    
2082            public static boolean isSkipPortletContentRendering(
2083                    Group group, LayoutTypePortlet layoutTypePortlet,
2084                    PortletDisplay portletDisplay, String portletName) {
2085    
2086                    return getPortal().isSkipPortletContentRendering(
2087                            group, layoutTypePortlet, portletDisplay, portletName);
2088            }
2089    
2090            public static boolean isSystemGroup(String groupName) {
2091                    return getPortal().isSystemGroup(groupName);
2092            }
2093    
2094            public static boolean isSystemRole(String roleName) {
2095                    return getPortal().isSystemRole(roleName);
2096            }
2097    
2098            public static boolean isUpdateAvailable() {
2099                    return getPortal().isUpdateAvailable();
2100            }
2101    
2102            public static boolean isValidResourceId(String resourceId) {
2103                    return getPortal().isValidResourceId(resourceId);
2104            }
2105    
2106            public static boolean removePortalEventListener(
2107                    PortalInetSocketAddressEventListener
2108                            portalInetSocketAddressEventListener) {
2109    
2110                    return getPortal().removePortalInetSocketAddressEventListener(
2111                            portalInetSocketAddressEventListener);
2112            }
2113    
2114            public static void resetCDNHosts() {
2115                    getPortal().resetCDNHosts();
2116            }
2117    
2118            public static String resetPortletParameters(String url, String portletId) {
2119                    return getPortal().resetPortletParameters(url, portletId);
2120            }
2121    
2122            public static void sendError(
2123                            Exception e, ActionRequest actionRequest,
2124                            ActionResponse actionResponse)
2125                    throws IOException {
2126    
2127                    getPortal().sendError(e, actionRequest, actionResponse);
2128            }
2129    
2130            public static void sendError(
2131                            Exception e, HttpServletRequest request,
2132                            HttpServletResponse response)
2133                    throws IOException, ServletException {
2134    
2135                    getPortal().sendError(e, request, response);
2136            }
2137    
2138            public static void sendError(
2139                            int status, Exception e, ActionRequest actionRequest,
2140                            ActionResponse actionResponse)
2141                    throws IOException {
2142    
2143                    getPortal().sendError(status, e, actionRequest, actionResponse);
2144            }
2145    
2146            public static void sendError(
2147                            int status, Exception e, HttpServletRequest request,
2148                            HttpServletResponse response)
2149                    throws IOException, ServletException {
2150    
2151                    getPortal().sendError(status, e, request, response);
2152            }
2153    
2154            public static void sendRSSFeedsDisabledError(
2155                            HttpServletRequest request, HttpServletResponse response)
2156                    throws IOException, ServletException {
2157    
2158                    getPortal().sendRSSFeedsDisabledError(request, response);
2159            }
2160    
2161            public static void sendRSSFeedsDisabledError(
2162                            PortletRequest portletRequest, PortletResponse portletResponse)
2163                    throws IOException, ServletException {
2164    
2165                    getPortal().sendRSSFeedsDisabledError(portletRequest, portletResponse);
2166            }
2167    
2168            /**
2169             * Sets the description for a page. This overrides the existing page
2170             * description.
2171             */
2172            public static void setPageDescription(
2173                    String description, HttpServletRequest request) {
2174    
2175                    getPortal().setPageDescription(description, request);
2176            }
2177    
2178            /**
2179             * Sets the keywords for a page. This overrides the existing page keywords.
2180             */
2181            public static void setPageKeywords(
2182                    String keywords, HttpServletRequest request) {
2183    
2184                    getPortal().setPageKeywords(keywords, request);
2185            }
2186    
2187            /**
2188             * Sets the subtitle for a page. This overrides the existing page subtitle.
2189             */
2190            public static void setPageSubtitle(
2191                    String subtitle, HttpServletRequest request) {
2192    
2193                    getPortal().setPageSubtitle(subtitle, request);
2194            }
2195    
2196            /**
2197             * Sets the whole title for a page. This overrides the existing page whole
2198             * title.
2199             */
2200            public static void setPageTitle(String title, HttpServletRequest request) {
2201                    getPortal().setPageTitle(title, request);
2202            }
2203    
2204            public static void setPortalInetSocketAddresses(
2205                    HttpServletRequest request) {
2206    
2207                    getPortal().setPortalInetSocketAddresses(request);
2208            }
2209    
2210            /**
2211             * Sets the port obtained on the first request to the portal.
2212             *
2213             * @deprecated As of 7.0.0, replaced by {@link
2214             *             #setPortalInetSocketAddresses(HttpServletRequest)}
2215             */
2216            @Deprecated
2217            public static void setPortalPort(HttpServletRequest request) {
2218                    getPortal().setPortalPort(request);
2219            }
2220    
2221            public static void storePreferences(PortletPreferences portletPreferences)
2222                    throws IOException, ValidatorException {
2223    
2224                    getPortal().storePreferences(portletPreferences);
2225            }
2226    
2227            public static String[] stripURLAnchor(String url, String separator) {
2228                    return getPortal().stripURLAnchor(url, separator);
2229            }
2230    
2231            public static String transformCustomSQL(String sql) {
2232                    return getPortal().transformCustomSQL(sql);
2233            }
2234    
2235            public static String transformSQL(String sql) {
2236                    return getPortal().transformSQL(sql);
2237            }
2238    
2239            public static void updateImageId(
2240                            BaseModel<?> baseModel, boolean hasImage, byte[] bytes,
2241                            String fieldName, long maxSize, int maxHeight, int maxWidth)
2242                    throws PortalException {
2243    
2244                    getPortal().updateImageId(
2245                            baseModel, hasImage, bytes, fieldName, maxSize, maxHeight,
2246                            maxWidth);
2247            }
2248    
2249            public static PortletMode updatePortletMode(
2250                            String portletId, User user, Layout layout, PortletMode portletMode,
2251                            HttpServletRequest request)
2252                    throws PortalException {
2253    
2254                    return getPortal().updatePortletMode(
2255                            portletId, user, layout, portletMode, request);
2256            }
2257    
2258            public static String updateRedirect(
2259                    String redirect, String oldPath, String newPath) {
2260    
2261                    return getPortal().updateRedirect(redirect, oldPath, newPath);
2262            }
2263    
2264            public static WindowState updateWindowState(
2265                    String portletId, User user, Layout layout, WindowState windowState,
2266                    HttpServletRequest request) {
2267    
2268                    return getPortal().updateWindowState(
2269                            portletId, user, layout, windowState, request);
2270            }
2271    
2272            /**
2273             * @deprecated As of 7.0.0, replaced by {@link
2274             *             #removePortalEventListener(
2275             *             PortalInetSocketAddressEventListener)}
2276             */
2277            @Deprecated
2278            public void removePortalPortEventListener(
2279                    PortalPortEventListener portalPortEventListener) {
2280    
2281                    getPortal().removePortalPortEventListener(portalPortEventListener);
2282            }
2283    
2284            public void setPortal(Portal portal) {
2285                    PortalRuntimePermission.checkSetBeanProperty(getClass());
2286    
2287                    _portal = portal;
2288            }
2289    
2290            private static Portal _portal;
2291    
2292    }