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 getForwardedHost(HttpServletRequest request) {
916                    return getPortal().getForwardedHost(request);
917            }
918    
919            public static int getForwardedPort(HttpServletRequest request) {
920                    return getPortal().getForwardedPort(request);
921            }
922    
923            public static String getFullName(
924                    String firstName, String middleName, String lastName) {
925    
926                    return getPortal().getFullName(firstName, middleName, lastName);
927            }
928    
929            public static String getGlobalLibDir() {
930                    return getPortal().getGlobalLibDir();
931            }
932    
933            public static String getGoogleGadgetURL(
934                            Portlet portlet, ThemeDisplay themeDisplay)
935                    throws PortalException {
936    
937                    return getPortal().getGoogleGadgetURL(portlet, themeDisplay);
938            }
939    
940            public static String getGroupFriendlyURL(
941                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
942                    throws PortalException {
943    
944                    return getPortal().getGroupFriendlyURL(layoutSet, themeDisplay);
945            }
946    
947            public static String getGroupFriendlyURL(
948                            LayoutSet layoutSet, ThemeDisplay themeDisplay, Locale locale)
949                    throws PortalException {
950    
951                    return getPortal().getGroupFriendlyURL(layoutSet, themeDisplay, locale);
952            }
953    
954            public static int[] getGroupFriendlyURLIndex(String requestURI) {
955                    return getPortal().getGroupFriendlyURLIndex(requestURI);
956            }
957    
958            public static String[] getGroupPermissions(HttpServletRequest request) {
959                    return getPortal().getGroupPermissions(request);
960            }
961    
962            public static String[] getGroupPermissions(
963                    HttpServletRequest request, String className) {
964    
965                    return getPortal().getGroupPermissions(request, className);
966            }
967    
968            public static String[] getGroupPermissions(PortletRequest portletRequest) {
969                    return getPortal().getGroupPermissions(portletRequest);
970            }
971    
972            public static String[] getGroupPermissions(
973                    PortletRequest portletRequest, String className) {
974    
975                    return getPortal().getGroupPermissions(portletRequest, className);
976            }
977    
978            public static String[] getGuestPermissions(HttpServletRequest request) {
979                    return getPortal().getGuestPermissions(request);
980            }
981    
982            public static String[] getGuestPermissions(
983                    HttpServletRequest request, String className) {
984    
985                    return getPortal().getGuestPermissions(request, className);
986            }
987    
988            public static String[] getGuestPermissions(PortletRequest portletRequest) {
989                    return getPortal().getGuestPermissions(portletRequest);
990            }
991    
992            public static String[] getGuestPermissions(
993                    PortletRequest portletRequest, String className) {
994    
995                    return getPortal().getGuestPermissions(portletRequest, className);
996            }
997    
998            public static String getHomeURL(HttpServletRequest request)
999                    throws PortalException {
1000    
1001                    return getPortal().getHomeURL(request);
1002            }
1003    
1004            public static String getHost(HttpServletRequest request) {
1005                    return getPortal().getHost(request);
1006            }
1007    
1008            public static String getHost(PortletRequest portletRequest) {
1009                    return getPortal().getHost(portletRequest);
1010            }
1011    
1012            public static HttpServletRequest getHttpServletRequest(
1013                    PortletRequest portletRequest) {
1014    
1015                    return getPortal().getHttpServletRequest(portletRequest);
1016            }
1017    
1018            public static HttpServletResponse getHttpServletResponse(
1019                    PortletResponse portletResponse) {
1020    
1021                    return getPortal().getHttpServletResponse(portletResponse);
1022            }
1023    
1024            public static String getI18nPathLanguageId(
1025                    Locale locale, String defaultI18nPathLanguageId) {
1026    
1027                    return getPortal().getI18nPathLanguageId(
1028                            locale, defaultI18nPathLanguageId);
1029            }
1030    
1031            /**
1032             * @deprecated As of 7.0.0, with no direct replacement
1033             */
1034            @Deprecated
1035            public static String getJournalArticleActualURL(
1036                            long groupId, boolean privateLayout, String mainPath,
1037                            String friendlyURL, Map<String, String[]> params,
1038                            Map<String, Object> requestContext)
1039                    throws PortalException {
1040    
1041                    return getPortal().getJournalArticleActualURL(
1042                            groupId, privateLayout, mainPath, friendlyURL, params,
1043                            requestContext);
1044            }
1045    
1046            /**
1047             * @deprecated As of 7.0.0, with no direct replacement
1048             */
1049            @Deprecated
1050            public static Layout getJournalArticleLayout(
1051                            long groupId, boolean privateLayout, String friendlyURL)
1052                    throws PortalException {
1053    
1054                    return getPortal().getJournalArticleLayout(
1055                            groupId, privateLayout, friendlyURL);
1056            }
1057    
1058            public static String getJsSafePortletId(String portletId) {
1059                    return getPortal().getJsSafePortletId(portletId);
1060            }
1061    
1062            public static String getLayoutActualURL(Layout layout) {
1063                    return getPortal().getLayoutActualURL(layout);
1064            }
1065    
1066            public static String getLayoutActualURL(Layout layout, String mainPath) {
1067                    return getPortal().getLayoutActualURL(layout, mainPath);
1068            }
1069    
1070            public static String getLayoutActualURL(
1071                            long groupId, boolean privateLayout, String mainPath,
1072                            String friendlyURL)
1073                    throws PortalException {
1074    
1075                    return getPortal().getLayoutActualURL(
1076                            groupId, privateLayout, mainPath, friendlyURL);
1077            }
1078    
1079            public static String getLayoutActualURL(
1080                            long groupId, boolean privateLayout, String mainPath,
1081                            String friendlyURL, Map<String, String[]> params,
1082                            Map<String, Object> requestContext)
1083                    throws PortalException {
1084    
1085                    return getPortal().getLayoutActualURL(
1086                            groupId, privateLayout, mainPath, friendlyURL, params,
1087                            requestContext);
1088            }
1089    
1090            public static String getLayoutFriendlyURL(
1091                            Layout layout, ThemeDisplay themeDisplay)
1092                    throws PortalException {
1093    
1094                    return getPortal().getLayoutFriendlyURL(layout, themeDisplay);
1095            }
1096    
1097            public static String getLayoutFriendlyURL(
1098                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1099                    throws PortalException {
1100    
1101                    return getPortal().getLayoutFriendlyURL(layout, themeDisplay, locale);
1102            }
1103    
1104            public static LayoutFriendlyURLComposite getLayoutFriendlyURLComposite(
1105                            long groupId, boolean privateLayout, String friendlyURL,
1106                            Map<String, String[]> params, Map<String, Object> requestContext)
1107                    throws PortalException {
1108    
1109                    return getPortal().getLayoutFriendlyURLComposite(
1110                            groupId, privateLayout, friendlyURL, params, requestContext);
1111            }
1112    
1113            public static String getLayoutFullURL(
1114                            Layout layout, ThemeDisplay themeDisplay)
1115                    throws PortalException {
1116    
1117                    return getPortal().getLayoutFullURL(layout, themeDisplay);
1118            }
1119    
1120            public static String getLayoutFullURL(
1121                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1122                    throws PortalException {
1123    
1124                    return getPortal().getLayoutFullURL(layout, themeDisplay, doAsUser);
1125            }
1126    
1127            public static String getLayoutFullURL(long groupId, String portletId)
1128                    throws PortalException {
1129    
1130                    return getPortal().getLayoutFullURL(groupId, portletId);
1131            }
1132    
1133            public static String getLayoutFullURL(
1134                            long groupId, String portletId, boolean secure)
1135                    throws PortalException {
1136    
1137                    return getPortal().getLayoutFullURL(groupId, portletId, secure);
1138            }
1139    
1140            public static String getLayoutFullURL(ThemeDisplay themeDisplay)
1141                    throws PortalException {
1142    
1143                    return getPortal().getLayoutFullURL(themeDisplay);
1144            }
1145    
1146            public static String getLayoutRelativeURL(
1147                            Layout layout, ThemeDisplay themeDisplay)
1148                    throws PortalException {
1149    
1150                    return getPortal().getLayoutRelativeURL(layout, themeDisplay);
1151            }
1152    
1153            public static String getLayoutRelativeURL(
1154                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1155                    throws PortalException {
1156    
1157                    return getPortal().getLayoutRelativeURL(layout, themeDisplay, doAsUser);
1158            }
1159    
1160            public static String getLayoutSetDisplayURL(
1161                            LayoutSet layoutSet, boolean secureConnection)
1162                    throws PortalException {
1163    
1164                    return getPortal().getLayoutSetDisplayURL(layoutSet, secureConnection);
1165            }
1166    
1167            public static String getLayoutSetFriendlyURL(
1168                            LayoutSet layoutSet, ThemeDisplay themeDisplay)
1169                    throws PortalException {
1170    
1171                    return getPortal().getLayoutSetFriendlyURL(layoutSet, themeDisplay);
1172            }
1173    
1174            public static String getLayoutTarget(Layout layout) {
1175                    return getPortal().getLayoutTarget(layout);
1176            }
1177    
1178            public static String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
1179                    throws PortalException {
1180    
1181                    return getPortal().getLayoutURL(layout, themeDisplay);
1182            }
1183    
1184            public static String getLayoutURL(
1185                            Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
1186                    throws PortalException {
1187    
1188                    return getPortal().getLayoutURL(layout, themeDisplay, doAsUser);
1189            }
1190    
1191            public static String getLayoutURL(
1192                            Layout layout, ThemeDisplay themeDisplay, Locale locale)
1193                    throws PortalException {
1194    
1195                    return getPortal().getLayoutURL(layout, themeDisplay, locale);
1196            }
1197    
1198            public static String getLayoutURL(ThemeDisplay themeDisplay)
1199                    throws PortalException {
1200    
1201                    return getPortal().getLayoutURL(themeDisplay);
1202            }
1203    
1204            public static LiferayPortletRequest getLiferayPortletRequest(
1205                    PortletRequest portletRequest) {
1206    
1207                    return getPortal().getLiferayPortletRequest(portletRequest);
1208            }
1209    
1210            public static LiferayPortletResponse getLiferayPortletResponse(
1211                    PortletResponse portletResponse) {
1212    
1213                    return getPortal().getLiferayPortletResponse(portletResponse);
1214            }
1215    
1216            public static Locale getLocale(HttpServletRequest request) {
1217                    return getPortal().getLocale(request);
1218            }
1219    
1220            public static Locale getLocale(
1221                    HttpServletRequest request, HttpServletResponse response,
1222                    boolean initialize) {
1223    
1224                    return getPortal().getLocale(request, response, initialize);
1225            }
1226    
1227            public static Locale getLocale(PortletRequest portletRequest) {
1228                    return getPortal().getLocale(portletRequest);
1229            }
1230    
1231            public static String getLocalizedFriendlyURL(
1232                            HttpServletRequest request, Layout layout, Locale locale,
1233                            Locale originalLocale)
1234                    throws Exception {
1235    
1236                    return getPortal().getLocalizedFriendlyURL(
1237                            request, layout, locale, originalLocale);
1238            }
1239    
1240            public static String getMailId(
1241                    String mx, String popPortletPrefix, Object... ids) {
1242    
1243                    return getPortal().getMailId(mx, popPortletPrefix, ids);
1244            }
1245    
1246            public static String getNetvibesURL(
1247                            Portlet portlet, ThemeDisplay themeDisplay)
1248                    throws PortalException {
1249    
1250                    return getPortal().getNetvibesURL(portlet, themeDisplay);
1251            }
1252    
1253            public static String getNewPortletTitle(
1254                    String portletTitle, String oldScopeName, String newScopeName) {
1255    
1256                    return getPortal().getNewPortletTitle(
1257                            portletTitle, oldScopeName, newScopeName);
1258            }
1259    
1260            public static HttpServletRequest getOriginalServletRequest(
1261                    HttpServletRequest request) {
1262    
1263                    return getPortal().getOriginalServletRequest(request);
1264            }
1265    
1266            public static String getPathContext() {
1267                    return getPortal().getPathContext();
1268            }
1269    
1270            public static String getPathContext(HttpServletRequest request) {
1271                    return getPortal().getPathContext(request);
1272            }
1273    
1274            public static String getPathContext(PortletRequest portletRequest) {
1275                    return getPortal().getPathContext(portletRequest);
1276            }
1277    
1278            public static String getPathContext(String contextPath) {
1279                    return getPortal().getPathContext(contextPath);
1280            }
1281    
1282            public static String getPathFriendlyURLPrivateGroup() {
1283                    return getPortal().getPathFriendlyURLPrivateGroup();
1284            }
1285    
1286            public static String getPathFriendlyURLPrivateUser() {
1287                    return getPortal().getPathFriendlyURLPrivateUser();
1288            }
1289    
1290            public static String getPathFriendlyURLPublic() {
1291                    return getPortal().getPathFriendlyURLPublic();
1292            }
1293    
1294            public static String getPathImage() {
1295                    return getPortal().getPathImage();
1296            }
1297    
1298            public static String getPathMain() {
1299                    return getPortal().getPathMain();
1300            }
1301    
1302            public static String getPathModule() {
1303                    return getPortal().getPathModule();
1304            }
1305    
1306            public static String getPathProxy() {
1307                    return getPortal().getPathProxy();
1308            }
1309    
1310            public static long getPlidFromFriendlyURL(
1311                    long companyId, String friendlyURL) {
1312    
1313                    return getPortal().getPlidFromFriendlyURL(companyId, friendlyURL);
1314            }
1315    
1316            public static long getPlidFromPortletId(
1317                            long groupId, boolean privateLayout, String portletId)
1318                    throws PortalException {
1319    
1320                    return getPortal().getPlidFromPortletId(
1321                            groupId, privateLayout, portletId);
1322            }
1323    
1324            public static long getPlidFromPortletId(long groupId, String portletId)
1325                    throws PortalException {
1326    
1327                    return getPortal().getPlidFromPortletId(groupId, portletId);
1328            }
1329    
1330            public static Portal getPortal() {
1331                    PortalRuntimePermission.checkGetBeanProperty(PortalUtil.class);
1332    
1333                    return _portal;
1334            }
1335    
1336            public static PortalInetSocketAddressEventListener[]
1337                    getPortalInetSocketAddressEventListeners() {
1338    
1339                    return getPortal().getPortalInetSocketAddressEventListeners();
1340            }
1341    
1342            public static String getPortalLibDir() {
1343                    return getPortal().getPortalLibDir();
1344            }
1345    
1346            public static InetAddress getPortalLocalInetAddress(boolean secure) {
1347                    return getPortal().getPortalLocalInetAddress(secure);
1348            }
1349    
1350            public static int getPortalLocalPort(boolean secure) {
1351                    return getPortal().getPortalLocalPort(secure);
1352            }
1353    
1354            /**
1355             * @deprecated As of 7.0.0, replaced by {@link
1356             *             #getPortalServerPort(boolean)}
1357             */
1358            @Deprecated
1359            public static int getPortalPort(boolean secure) {
1360                    return getPortal().getPortalPort(secure);
1361            }
1362    
1363            public static Properties getPortalProperties() {
1364                    return getPortal().getPortalProperties();
1365            }
1366    
1367            public static InetAddress getPortalServerInetAddress(boolean secure) {
1368                    return getPortal().getPortalServerInetAddress(secure);
1369            }
1370    
1371            public static int getPortalServerPort(boolean secure) {
1372                    return getPortal().getPortalServerPort(secure);
1373            }
1374    
1375            public static String getPortalURL(HttpServletRequest request) {
1376                    return getPortal().getPortalURL(request);
1377            }
1378    
1379            public static String getPortalURL(
1380                    HttpServletRequest request, boolean secure) {
1381    
1382                    return getPortal().getPortalURL(request, secure);
1383            }
1384    
1385            public static String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
1386                    throws PortalException {
1387    
1388                    return getPortal().getPortalURL(layout, themeDisplay);
1389            }
1390    
1391            public static String getPortalURL(
1392                    LayoutSet layoutSet, ThemeDisplay themeDisplay) {
1393    
1394                    return getPortal().getPortalURL(layoutSet, themeDisplay);
1395            }
1396    
1397            public static String getPortalURL(PortletRequest portletRequest) {
1398                    return getPortal().getPortalURL(portletRequest);
1399            }
1400    
1401            public static String getPortalURL(
1402                    PortletRequest portletRequest, boolean secure) {
1403    
1404                    return getPortal().getPortalURL(portletRequest, secure);
1405            }
1406    
1407            public static String getPortalURL(
1408                    String serverName, int serverPort, boolean secure) {
1409    
1410                    return getPortal().getPortalURL(serverName, serverPort, secure);
1411            }
1412    
1413            public static String getPortalURL(ThemeDisplay themeDisplay)
1414                    throws PortalException {
1415    
1416                    return getPortal().getPortalURL(themeDisplay);
1417            }
1418    
1419            public static String getPortalWebDir() {
1420                    return getPortal().getPortalWebDir();
1421            }
1422    
1423            /**
1424             * @deprecated As of 7.0.0, replaced by {@link
1425             *             com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbUtil#getPortletBreadcrumbEntries(
1426             *             HttpServletRequest)}
1427             */
1428            @Deprecated
1429            public static List<BreadcrumbEntry> getPortletBreadcrumbs(
1430                    HttpServletRequest request) {
1431    
1432                    return getPortal().getPortletBreadcrumbs(request);
1433            }
1434    
1435            public static PortletConfig getPortletConfig(
1436                            long companyId, String portletId, ServletContext servletContext)
1437                    throws PortletException {
1438    
1439                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
1440                            companyId, portletId);
1441    
1442                    InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
1443                            portlet, servletContext);
1444    
1445                    return invokerPortlet.getPortletConfig();
1446            }
1447    
1448            public static String getPortletDescription(
1449                    Portlet portlet, ServletContext servletContext, Locale locale) {
1450    
1451                    return getPortal().getPortletDescription(
1452                            portlet, servletContext, locale);
1453            }
1454    
1455            public static String getPortletDescription(Portlet portlet, User user) {
1456                    return getPortal().getPortletDescription(portlet, user);
1457            }
1458    
1459            public static String getPortletDescription(
1460                    String portletId, Locale locale) {
1461    
1462                    return getPortal().getPortletDescription(portletId, locale);
1463            }
1464    
1465            public static String getPortletDescription(
1466                    String portletId, String languageId) {
1467    
1468                    return getPortal().getPortletDescription(portletId, languageId);
1469            }
1470    
1471            public static String getPortletDescription(String portletId, User user) {
1472                    return getPortal().getPortletDescription(portletId, user);
1473            }
1474    
1475            public static String getPortletId(HttpServletRequest request) {
1476                    return getPortal().getPortletId(request);
1477            }
1478    
1479            public static String getPortletId(PortletRequest portletRequest) {
1480                    return getPortal().getPortletId(portletRequest);
1481            }
1482    
1483            public static String getPortletLongTitle(Portlet portlet, Locale locale) {
1484                    return getPortal().getPortletLongTitle(portlet, locale);
1485            }
1486    
1487            public static String getPortletLongTitle(
1488                    Portlet portlet, ServletContext servletContext, Locale locale) {
1489    
1490                    return getPortal().getPortletLongTitle(portlet, servletContext, locale);
1491            }
1492    
1493            public static String getPortletLongTitle(
1494                    Portlet portlet, String languageId) {
1495    
1496                    return getPortal().getPortletLongTitle(portlet, languageId);
1497            }
1498    
1499            public static String getPortletLongTitle(Portlet portlet, User user) {
1500                    return getPortal().getPortletLongTitle(portlet, user);
1501            }
1502    
1503            public static String getPortletLongTitle(String portletId, Locale locale) {
1504                    return getPortal().getPortletLongTitle(portletId, locale);
1505            }
1506    
1507            public static String getPortletLongTitle(
1508                    String portletId, String languageId) {
1509    
1510                    return getPortal().getPortletLongTitle(portletId, languageId);
1511            }
1512    
1513            public static String getPortletLongTitle(String portletId, User user) {
1514                    return getPortal().getPortletLongTitle(portletId, user);
1515            }
1516    
1517            public static String getPortletNamespace(String portletId) {
1518                    return getPortal().getPortletNamespace(portletId);
1519            }
1520    
1521            public static String getPortletTitle(Portlet portlet, Locale locale) {
1522                    return getPortal().getPortletTitle(portlet, locale);
1523            }
1524    
1525            public static String getPortletTitle(
1526                    Portlet portlet, ServletContext servletContext, Locale locale) {
1527    
1528                    return getPortal().getPortletTitle(portlet, servletContext, locale);
1529            }
1530    
1531            public static String getPortletTitle(Portlet portlet, String languageId) {
1532                    return getPortal().getPortletTitle(portlet, languageId);
1533            }
1534    
1535            public static String getPortletTitle(Portlet portlet, User user) {
1536                    return getPortal().getPortletTitle(portlet, user);
1537            }
1538    
1539            public static String getPortletTitle(PortletRequest portletRequest) {
1540                    return getPortal().getPortletTitle(portletRequest);
1541            }
1542    
1543            public static String getPortletTitle(PortletResponse portletResponse) {
1544                    return getPortal().getPortletTitle(portletResponse);
1545            }
1546    
1547            public static String getPortletTitle(String portletId, Locale locale) {
1548                    return getPortal().getPortletTitle(portletId, locale);
1549            }
1550    
1551            public static String getPortletTitle(
1552                    String portletId, ResourceBundle resourceBundle) {
1553    
1554                    return getPortal().getPortletTitle(portletId, resourceBundle);
1555            }
1556    
1557            public static String getPortletTitle(String portletId, String languageId) {
1558                    return getPortal().getPortletTitle(portletId, languageId);
1559            }
1560    
1561            public static String getPortletTitle(String portletId, User user) {
1562                    return getPortal().getPortletTitle(portletId, user);
1563            }
1564    
1565            public static String getPortletXmlFileName() {
1566                    return getPortal().getPortletXmlFileName();
1567            }
1568    
1569            public static PortletPreferences getPreferences(
1570                    HttpServletRequest request) {
1571    
1572                    return getPortal().getPreferences(request);
1573            }
1574    
1575            public static PreferencesValidator getPreferencesValidator(
1576                    Portlet portlet) {
1577    
1578                    return getPortal().getPreferencesValidator(portlet);
1579            }
1580    
1581            public static String getRelativeHomeURL(HttpServletRequest request)
1582                    throws PortalException {
1583    
1584                    return getPortal().getRelativeHomeURL(request);
1585            }
1586    
1587            public static ResourceBundle getResourceBundle(Locale locale) {
1588                    return getPortal().getResourceBundle(locale);
1589            }
1590    
1591            public static long getScopeGroupId(HttpServletRequest request)
1592                    throws PortalException {
1593    
1594                    return getPortal().getScopeGroupId(request);
1595            }
1596    
1597            public static long getScopeGroupId(
1598                            HttpServletRequest request, String portletId)
1599                    throws PortalException {
1600    
1601                    return getPortal().getScopeGroupId(request, portletId);
1602            }
1603    
1604            public static long getScopeGroupId(
1605                            HttpServletRequest request, String portletId,
1606                            boolean checkStagingGroup)
1607                    throws PortalException {
1608    
1609                    return getPortal().getScopeGroupId(
1610                            request, portletId, checkStagingGroup);
1611            }
1612    
1613            public static long getScopeGroupId(Layout layout) {
1614                    return getPortal().getScopeGroupId(layout);
1615            }
1616    
1617            public static long getScopeGroupId(Layout layout, String portletId) {
1618                    return getPortal().getScopeGroupId(layout, portletId);
1619            }
1620    
1621            public static long getScopeGroupId(long plid) {
1622                    return getPortal().getScopeGroupId(plid);
1623            }
1624    
1625            public static long getScopeGroupId(PortletRequest portletRequest)
1626                    throws PortalException {
1627    
1628                    return getPortal().getScopeGroupId(portletRequest);
1629            }
1630    
1631            public static User getSelectedUser(HttpServletRequest request)
1632                    throws PortalException {
1633    
1634                    return getPortal().getSelectedUser(request);
1635            }
1636    
1637            public static User getSelectedUser(
1638                            HttpServletRequest request, boolean checkPermission)
1639                    throws PortalException {
1640    
1641                    return getPortal().getSelectedUser(request, checkPermission);
1642            }
1643    
1644            public static User getSelectedUser(PortletRequest portletRequest)
1645                    throws PortalException {
1646    
1647                    return getPortal().getSelectedUser(portletRequest);
1648            }
1649    
1650            public static User getSelectedUser(
1651                            PortletRequest portletRequest, boolean checkPermission)
1652                    throws PortalException {
1653    
1654                    return getPortal().getSelectedUser(portletRequest, checkPermission);
1655            }
1656    
1657            public static String getServletContextName() {
1658                    return getPortal().getServletContextName();
1659            }
1660    
1661            public static long[] getSharedContentSiteGroupIds(
1662                            long companyId, long groupId, long userId)
1663                    throws PortalException {
1664    
1665                    return getPortal().getSharedContentSiteGroupIds(
1666                            companyId, groupId, userId);
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                    HttpServletRequest request, ThemeDisplay themeDisplay,
1677                    String portletId) {
1678    
1679                    return getPortal().getSiteAdministrationURL(
1680                            request, themeDisplay, portletId);
1681            }
1682    
1683            /**
1684             * @deprecated As of 7.0.0, replaced by {@link
1685             *             #getControlPanelPortletURL(PortletRequest, Group, String,
1686             *             long, String)}
1687             */
1688            @Deprecated
1689            public static PortletURL getSiteAdministrationURL(
1690                    PortletResponse portletResponse, ThemeDisplay themeDisplay,
1691                    String portletName) {
1692    
1693                    return getPortal().getSiteAdministrationURL(
1694                            portletResponse, themeDisplay, portletName);
1695            }
1696    
1697            /**
1698             * @deprecated As of 7.0.0, replaced by {@link
1699             *             #getCurrentAndAncestorSiteGroupIds(long)}
1700             */
1701            @Deprecated
1702            public static long[] getSiteAndCompanyGroupIds(long groupId)
1703                    throws PortalException {
1704    
1705                    return getPortal().getSiteAndCompanyGroupIds(groupId);
1706            }
1707    
1708            /**
1709             * @deprecated As of 7.0.0, replaced by {@link
1710             *             #getCurrentAndAncestorSiteGroupIds(long)}
1711             */
1712            @Deprecated
1713            public static long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
1714                    throws PortalException {
1715    
1716                    return getPortal().getSiteAndCompanyGroupIds(themeDisplay);
1717            }
1718    
1719            public static Locale getSiteDefaultLocale(long groupId)
1720                    throws PortalException {
1721    
1722                    return getPortal().getSiteDefaultLocale(groupId);
1723            }
1724    
1725            public static long getSiteGroupId(long scopeGroupId) {
1726                    return getPortal().getSiteGroupId(scopeGroupId);
1727            }
1728    
1729            public static String getSiteLoginURL(ThemeDisplay themeDisplay)
1730                    throws PortalException {
1731    
1732                    return getPortal().getSiteLoginURL(themeDisplay);
1733            }
1734    
1735            public static String getStaticResourceURL(
1736                    HttpServletRequest request, String uri) {
1737    
1738                    return getPortal().getStaticResourceURL(request, uri);
1739            }
1740    
1741            public static String getStaticResourceURL(
1742                    HttpServletRequest request, String uri, long timestamp) {
1743    
1744                    return getPortal().getStaticResourceURL(request, uri, timestamp);
1745            }
1746    
1747            public static String getStaticResourceURL(
1748                    HttpServletRequest request, String uri, String queryString) {
1749    
1750                    return getPortal().getStaticResourceURL(request, uri, queryString);
1751            }
1752    
1753            public static String getStaticResourceURL(
1754                    HttpServletRequest request, String uri, String queryString,
1755                    long timestamp) {
1756    
1757                    return getPortal().getStaticResourceURL(
1758                            request, uri, queryString, timestamp);
1759            }
1760    
1761            public static String getStrutsAction(HttpServletRequest request) {
1762                    return getPortal().getStrutsAction(request);
1763            }
1764    
1765            public static String[] getSystemGroups() {
1766                    return getPortal().getSystemGroups();
1767            }
1768    
1769            public static String[] getSystemOrganizationRoles() {
1770                    return getPortal().getSystemOrganizationRoles();
1771            }
1772    
1773            public static String[] getSystemRoles() {
1774                    return getPortal().getSystemRoles();
1775            }
1776    
1777            public static String[] getSystemSiteRoles() {
1778                    return getPortal().getSystemSiteRoles();
1779            }
1780    
1781            public static String getUniqueElementId(
1782                    HttpServletRequest request, String namespace, String id) {
1783    
1784                    return getPortal().getUniqueElementId(request, namespace, id);
1785            }
1786    
1787            public static String getUniqueElementId(
1788                    PortletRequest request, String namespace, String id) {
1789    
1790                    return getPortal().getUniqueElementId(request, namespace, id);
1791            }
1792    
1793            public static UploadPortletRequest getUploadPortletRequest(
1794                    PortletRequest portletRequest) {
1795    
1796                    return getPortal().getUploadPortletRequest(portletRequest);
1797            }
1798    
1799            public static UploadServletRequest getUploadServletRequest(
1800                    HttpServletRequest request) {
1801    
1802                    return getPortal().getUploadServletRequest(request);
1803            }
1804    
1805            public static Date getUptime() {
1806                    return getPortal().getUptime();
1807            }
1808    
1809            public static String getURLWithSessionId(String url, String sessionId) {
1810                    return getPortal().getURLWithSessionId(url, sessionId);
1811            }
1812    
1813            public static User getUser(HttpServletRequest request)
1814                    throws PortalException {
1815    
1816                    return getPortal().getUser(request);
1817            }
1818    
1819            public static User getUser(PortletRequest portletRequest)
1820                    throws PortalException {
1821    
1822                    return getPortal().getUser(portletRequest);
1823            }
1824    
1825            public static String getUserEmailAddress(long userId) {
1826                    return getPortal().getUserEmailAddress(userId);
1827            }
1828    
1829            public static long getUserId(HttpServletRequest request) {
1830                    return getPortal().getUserId(request);
1831            }
1832    
1833            public static long getUserId(PortletRequest portletRequest) {
1834                    return getPortal().getUserId(portletRequest);
1835            }
1836    
1837            public static String getUserName(BaseModel<?> baseModel) {
1838                    return getPortal().getUserName(baseModel);
1839            }
1840    
1841            public static String getUserName(long userId, String defaultUserName) {
1842                    return getPortal().getUserName(userId, defaultUserName);
1843            }
1844    
1845            public static String getUserName(
1846                    long userId, String defaultUserName, HttpServletRequest request) {
1847    
1848                    return getPortal().getUserName(userId, defaultUserName, request);
1849            }
1850    
1851            public static String getUserName(
1852                    long userId, String defaultUserName, String userAttribute) {
1853    
1854                    return getPortal().getUserName(userId, defaultUserName, userAttribute);
1855            }
1856    
1857            public static String getUserName(
1858                    long userId, String defaultUserName, String userAttribute,
1859                    HttpServletRequest request) {
1860    
1861                    return getPortal().getUserName(
1862                            userId, defaultUserName, userAttribute, request);
1863            }
1864    
1865            public static String getUserPassword(HttpServletRequest request) {
1866                    return getPortal().getUserPassword(request);
1867            }
1868    
1869            public static String getUserPassword(HttpSession session) {
1870                    return getPortal().getUserPassword(session);
1871            }
1872    
1873            public static String getUserPassword(PortletRequest portletRequest) {
1874                    return getPortal().getUserPassword(portletRequest);
1875            }
1876    
1877            /**
1878             * @deprecated As of 7.0.0, with no direct replacement
1879             */
1880            @Deprecated
1881            public static String getUserValue(
1882                    long userId, String param, String defaultValue) {
1883    
1884                    return getPortal().getUserValue(userId, param, defaultValue);
1885            }
1886    
1887            public static String getValidPortalDomain(long companyId, String domain) {
1888                    return getPortal().getValidPortalDomain(companyId, domain);
1889            }
1890    
1891            public static long getValidUserId(long companyId, long userId)
1892                    throws PortalException {
1893    
1894                    return getPortal().getValidUserId(companyId, userId);
1895            }
1896    
1897            public static String getVirtualHostname(LayoutSet layoutSet) {
1898                    return getPortal().getVirtualHostname(layoutSet);
1899            }
1900    
1901            /**
1902             * @deprecated As of 7.0.0, with no direct replacement
1903             */
1904            @Deprecated
1905            public static String getVirtualLayoutActualURL(
1906                            long groupId, boolean privateLayout, String mainPath,
1907                            String friendlyURL, Map<String, String[]> params,
1908                            Map<String, Object> requestContext)
1909                    throws PortalException {
1910    
1911                    return getPortal().getVirtualLayoutActualURL(
1912                            groupId, privateLayout, mainPath, friendlyURL, params,
1913                            requestContext);
1914            }
1915    
1916            /**
1917             * @deprecated As of 7.0.0, with no direct replacement
1918             */
1919            @Deprecated
1920            public static LayoutFriendlyURLComposite
1921                            getVirtualLayoutFriendlyURLComposite(
1922                                    boolean privateLayout, String friendlyURL,
1923                                    Map<String, String[]> params,
1924                                    Map<String, Object> requestContext)
1925                    throws PortalException {
1926    
1927                    return getPortal().getVirtualLayoutFriendlyURLComposite(
1928                            privateLayout, friendlyURL, params, requestContext);
1929            }
1930    
1931            public static String getWidgetURL(
1932                            Portlet portlet, ThemeDisplay themeDisplay)
1933                    throws PortalException {
1934    
1935                    return getPortal().getWidgetURL(portlet, themeDisplay);
1936            }
1937    
1938            public static void initCustomSQL() {
1939                    getPortal().initCustomSQL();
1940            }
1941    
1942            public static User initUser(HttpServletRequest request) throws Exception {
1943                    return getPortal().initUser(request);
1944            }
1945    
1946            /**
1947             * @deprecated As of 7.0.0, with no direct replacement
1948             */
1949            @Deprecated
1950            public static void invokeTaglibDiscussion(
1951                            PortletConfig portletConfig, ActionRequest actionRequest,
1952                            ActionResponse actionResponse)
1953                    throws Exception {
1954    
1955                    getPortal().invokeTaglibDiscussion(
1956                            portletConfig, actionRequest, actionResponse);
1957            }
1958    
1959            /**
1960             * @deprecated As of 7.0.0, with no direct replacement
1961             */
1962            @Deprecated
1963            public static void invokeTaglibDiscussionPagination(
1964                            PortletConfig portletConfig, ResourceRequest resourceRequest,
1965                            ResourceResponse resourceResponse)
1966                    throws IOException, PortletException {
1967    
1968                    getPortal().invokeTaglibDiscussionPagination(
1969                            portletConfig, resourceRequest, resourceResponse);
1970            }
1971    
1972            public static boolean isCDNDynamicResourcesEnabled(
1973                            HttpServletRequest request)
1974                    throws PortalException {
1975    
1976                    return getPortal().isCDNDynamicResourcesEnabled(request);
1977            }
1978    
1979            public static boolean isCDNDynamicResourcesEnabled(long companyId) {
1980                    return getPortal().isCDNDynamicResourcesEnabled(companyId);
1981            }
1982    
1983            public static boolean isCompanyAdmin(User user) throws Exception {
1984                    return getPortal().isCompanyAdmin(user);
1985            }
1986    
1987            public static boolean isCompanyControlPanelPortlet(
1988                            String portletId, String category, ThemeDisplay themeDisplay)
1989                    throws PortalException {
1990    
1991                    return getPortal().isCompanyControlPanelPortlet(
1992                            portletId, category, themeDisplay);
1993            }
1994    
1995            public static boolean isCompanyControlPanelPortlet(
1996                            String portletId, ThemeDisplay themeDisplay)
1997                    throws PortalException {
1998    
1999                    return getPortal().isCompanyControlPanelPortlet(
2000                            portletId, themeDisplay);
2001            }
2002    
2003            public static boolean isControlPanelPortlet(
2004                    String portletId, String category, ThemeDisplay themeDisplay) {
2005    
2006                    return getPortal().isControlPanelPortlet(
2007                            portletId, category, themeDisplay);
2008            }
2009    
2010            public static boolean isControlPanelPortlet(
2011                    String portletId, ThemeDisplay themeDisplay) {
2012    
2013                    return getPortal().isControlPanelPortlet(portletId, themeDisplay);
2014            }
2015    
2016            public static boolean isForwardedSecure(HttpServletRequest request) {
2017                    return getPortal().isForwardedSecure(request);
2018            }
2019    
2020            public static boolean isGroupAdmin(User user, long groupId)
2021                    throws Exception {
2022    
2023                    return getPortal().isGroupAdmin(user, groupId);
2024            }
2025    
2026            public static boolean isGroupFriendlyURL(
2027                    String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
2028    
2029                    return getPortal().isGroupFriendlyURL(
2030                            fullURL, groupFriendlyURL, layoutFriendlyURL);
2031            }
2032    
2033            public static boolean isGroupOwner(User user, long groupId)
2034                    throws Exception {
2035    
2036                    return getPortal().isGroupOwner(user, groupId);
2037            }
2038    
2039            public static boolean isLayoutDescendant(Layout layout, long layoutId)
2040                    throws PortalException {
2041    
2042                    return getPortal().isLayoutDescendant(layout, layoutId);
2043            }
2044    
2045            public static boolean isLayoutSitemapable(Layout layout) {
2046                    return getPortal().isLayoutSitemapable(layout);
2047            }
2048    
2049            public static boolean isLoginRedirectRequired(HttpServletRequest request) {
2050                    return getPortal().isLoginRedirectRequired(request);
2051            }
2052    
2053            public static boolean isMethodGet(PortletRequest portletRequest) {
2054                    return getPortal().isMethodGet(portletRequest);
2055            }
2056    
2057            public static boolean isMethodPost(PortletRequest portletRequest) {
2058                    return getPortal().isMethodPost(portletRequest);
2059            }
2060    
2061            public static boolean isMultipartRequest(HttpServletRequest request) {
2062                    return getPortal().isMultipartRequest(request);
2063            }
2064    
2065            public static boolean isOmniadmin(long userId) {
2066                    return getPortal().isOmniadmin(userId);
2067            }
2068    
2069            public static boolean isOmniadmin(User user) {
2070                    return getPortal().isOmniadmin(user);
2071            }
2072    
2073            public static boolean isReservedParameter(String name) {
2074                    return getPortal().isReservedParameter(name);
2075            }
2076    
2077            public static boolean isRightToLeft(HttpServletRequest request) {
2078                    return getPortal().isRightToLeft(request);
2079            }
2080    
2081            public static boolean isRSSFeedsEnabled() {
2082                    return getPortal().isRSSFeedsEnabled();
2083            }
2084    
2085            public static boolean isSecure(HttpServletRequest request) {
2086                    return getPortal().isSecure(request);
2087            }
2088    
2089            public static boolean isSkipPortletContentProcesssing(
2090                            Group group, HttpServletRequest htpServletRequest,
2091                            LayoutTypePortlet layoutTypePortlet, PortletDisplay portletDisplay,
2092                            String portletName)
2093                    throws Exception {
2094    
2095                    return getPortal().isSkipPortletContentProcessing(
2096                            group, htpServletRequest, layoutTypePortlet, portletDisplay,
2097                            portletName);
2098            }
2099    
2100            public static boolean isSkipPortletContentRendering(
2101                    Group group, LayoutTypePortlet layoutTypePortlet,
2102                    PortletDisplay portletDisplay, String portletName) {
2103    
2104                    return getPortal().isSkipPortletContentRendering(
2105                            group, layoutTypePortlet, portletDisplay, portletName);
2106            }
2107    
2108            public static boolean isSystemGroup(String groupName) {
2109                    return getPortal().isSystemGroup(groupName);
2110            }
2111    
2112            public static boolean isSystemRole(String roleName) {
2113                    return getPortal().isSystemRole(roleName);
2114            }
2115    
2116            public static boolean isUpdateAvailable() {
2117                    return getPortal().isUpdateAvailable();
2118            }
2119    
2120            public static boolean isValidResourceId(String resourceId) {
2121                    return getPortal().isValidResourceId(resourceId);
2122            }
2123    
2124            public static boolean removePortalEventListener(
2125                    PortalInetSocketAddressEventListener
2126                            portalInetSocketAddressEventListener) {
2127    
2128                    return getPortal().removePortalInetSocketAddressEventListener(
2129                            portalInetSocketAddressEventListener);
2130            }
2131    
2132            public static void resetCDNHosts() {
2133                    getPortal().resetCDNHosts();
2134            }
2135    
2136            public static String resetPortletParameters(String url, String portletId) {
2137                    return getPortal().resetPortletParameters(url, portletId);
2138            }
2139    
2140            public static void sendError(
2141                            Exception e, ActionRequest actionRequest,
2142                            ActionResponse actionResponse)
2143                    throws IOException {
2144    
2145                    getPortal().sendError(e, actionRequest, actionResponse);
2146            }
2147    
2148            public static void sendError(
2149                            Exception e, HttpServletRequest request,
2150                            HttpServletResponse response)
2151                    throws IOException, ServletException {
2152    
2153                    getPortal().sendError(e, request, response);
2154            }
2155    
2156            public static void sendError(
2157                            int status, Exception e, ActionRequest actionRequest,
2158                            ActionResponse actionResponse)
2159                    throws IOException {
2160    
2161                    getPortal().sendError(status, e, actionRequest, actionResponse);
2162            }
2163    
2164            public static void sendError(
2165                            int status, Exception e, HttpServletRequest request,
2166                            HttpServletResponse response)
2167                    throws IOException, ServletException {
2168    
2169                    getPortal().sendError(status, e, request, response);
2170            }
2171    
2172            public static void sendRSSFeedsDisabledError(
2173                            HttpServletRequest request, HttpServletResponse response)
2174                    throws IOException, ServletException {
2175    
2176                    getPortal().sendRSSFeedsDisabledError(request, response);
2177            }
2178    
2179            public static void sendRSSFeedsDisabledError(
2180                            PortletRequest portletRequest, PortletResponse portletResponse)
2181                    throws IOException, ServletException {
2182    
2183                    getPortal().sendRSSFeedsDisabledError(portletRequest, portletResponse);
2184            }
2185    
2186            /**
2187             * Sets the description for a page. This overrides the existing page
2188             * description.
2189             */
2190            public static void setPageDescription(
2191                    String description, HttpServletRequest request) {
2192    
2193                    getPortal().setPageDescription(description, request);
2194            }
2195    
2196            /**
2197             * Sets the keywords for a page. This overrides the existing page keywords.
2198             */
2199            public static void setPageKeywords(
2200                    String keywords, HttpServletRequest request) {
2201    
2202                    getPortal().setPageKeywords(keywords, request);
2203            }
2204    
2205            /**
2206             * Sets the subtitle for a page. This overrides the existing page subtitle.
2207             */
2208            public static void setPageSubtitle(
2209                    String subtitle, HttpServletRequest request) {
2210    
2211                    getPortal().setPageSubtitle(subtitle, request);
2212            }
2213    
2214            /**
2215             * Sets the whole title for a page. This overrides the existing page whole
2216             * title.
2217             */
2218            public static void setPageTitle(String title, HttpServletRequest request) {
2219                    getPortal().setPageTitle(title, request);
2220            }
2221    
2222            public static void setPortalInetSocketAddresses(
2223                    HttpServletRequest request) {
2224    
2225                    getPortal().setPortalInetSocketAddresses(request);
2226            }
2227    
2228            /**
2229             * Sets the port obtained on the first request to the portal.
2230             *
2231             * @deprecated As of 7.0.0, replaced by {@link
2232             *             #setPortalInetSocketAddresses(HttpServletRequest)}
2233             */
2234            @Deprecated
2235            public static void setPortalPort(HttpServletRequest request) {
2236                    getPortal().setPortalPort(request);
2237            }
2238    
2239            public static void storePreferences(PortletPreferences portletPreferences)
2240                    throws IOException, ValidatorException {
2241    
2242                    getPortal().storePreferences(portletPreferences);
2243            }
2244    
2245            public static String[] stripURLAnchor(String url, String separator) {
2246                    return getPortal().stripURLAnchor(url, separator);
2247            }
2248    
2249            public static String transformCustomSQL(String sql) {
2250                    return getPortal().transformCustomSQL(sql);
2251            }
2252    
2253            public static String transformSQL(String sql) {
2254                    return getPortal().transformSQL(sql);
2255            }
2256    
2257            public static void updateImageId(
2258                            BaseModel<?> baseModel, boolean hasImage, byte[] bytes,
2259                            String fieldName, long maxSize, int maxHeight, int maxWidth)
2260                    throws PortalException {
2261    
2262                    getPortal().updateImageId(
2263                            baseModel, hasImage, bytes, fieldName, maxSize, maxHeight,
2264                            maxWidth);
2265            }
2266    
2267            public static PortletMode updatePortletMode(
2268                            String portletId, User user, Layout layout, PortletMode portletMode,
2269                            HttpServletRequest request)
2270                    throws PortalException {
2271    
2272                    return getPortal().updatePortletMode(
2273                            portletId, user, layout, portletMode, request);
2274            }
2275    
2276            public static String updateRedirect(
2277                    String redirect, String oldPath, String newPath) {
2278    
2279                    return getPortal().updateRedirect(redirect, oldPath, newPath);
2280            }
2281    
2282            public static WindowState updateWindowState(
2283                    String portletId, User user, Layout layout, WindowState windowState,
2284                    HttpServletRequest request) {
2285    
2286                    return getPortal().updateWindowState(
2287                            portletId, user, layout, windowState, request);
2288            }
2289    
2290            /**
2291             * @deprecated As of 7.0.0, replaced by {@link
2292             *             #removePortalEventListener(
2293             *             PortalInetSocketAddressEventListener)}
2294             */
2295            @Deprecated
2296            public void removePortalPortEventListener(
2297                    PortalPortEventListener portalPortEventListener) {
2298    
2299                    getPortal().removePortalPortEventListener(portalPortEventListener);
2300            }
2301    
2302            public void setPortal(Portal portal) {
2303                    PortalRuntimePermission.checkSetBeanProperty(getClass());
2304    
2305                    _portal = portal;
2306            }
2307    
2308            private static Portal _portal;
2309    
2310    }