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.template;
016    
017    import com.liferay.portal.kernel.audit.AuditMessageFactoryUtil;
018    import com.liferay.portal.kernel.audit.AuditRouterUtil;
019    import com.liferay.portal.kernel.image.ImageToolUtil;
020    import com.liferay.portal.kernel.json.JSONFactoryUtil;
021    import com.liferay.portal.kernel.language.LanguageUtil;
022    import com.liferay.portal.kernel.language.UnicodeLanguageUtil;
023    import com.liferay.portal.kernel.log.Log;
024    import com.liferay.portal.kernel.log.LogFactoryUtil;
025    import com.liferay.portal.kernel.portlet.PortletModeFactory_IW;
026    import com.liferay.portal.kernel.portlet.PortletProvider;
027    import com.liferay.portal.kernel.portlet.PortletRequestModel;
028    import com.liferay.portal.kernel.portlet.PortletRequestModelFactory;
029    import com.liferay.portal.kernel.portlet.WindowStateFactory_IW;
030    import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
031    import com.liferay.portal.kernel.template.TemplateHandler;
032    import com.liferay.portal.kernel.template.TemplateHandlerRegistryUtil;
033    import com.liferay.portal.kernel.template.TemplateVariableGroup;
034    import com.liferay.portal.kernel.util.ArrayUtil_IW;
035    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
036    import com.liferay.portal.kernel.util.ClassLoaderUtil;
037    import com.liferay.portal.kernel.util.DateUtil_IW;
038    import com.liferay.portal.kernel.util.FastDateFormatFactoryUtil;
039    import com.liferay.portal.kernel.util.GetterUtil;
040    import com.liferay.portal.kernel.util.GetterUtil_IW;
041    import com.liferay.portal.kernel.util.HtmlUtil;
042    import com.liferay.portal.kernel.util.HttpUtil;
043    import com.liferay.portal.kernel.util.JavaConstants;
044    import com.liferay.portal.kernel.util.ListMergeable;
045    import com.liferay.portal.kernel.util.LocaleUtil;
046    import com.liferay.portal.kernel.util.ParamUtil_IW;
047    import com.liferay.portal.kernel.util.PrefsPropsUtil;
048    import com.liferay.portal.kernel.util.PropsUtil;
049    import com.liferay.portal.kernel.util.StaticFieldGetter;
050    import com.liferay.portal.kernel.util.StringPool;
051    import com.liferay.portal.kernel.util.StringUtil_IW;
052    import com.liferay.portal.kernel.util.TimeZoneUtil_IW;
053    import com.liferay.portal.kernel.util.UnicodeFormatter_IW;
054    import com.liferay.portal.kernel.util.Validator_IW;
055    import com.liferay.portal.kernel.xml.SAXReaderUtil;
056    import com.liferay.portal.model.Layout;
057    import com.liferay.portal.model.Theme;
058    import com.liferay.portal.service.GroupLocalService;
059    import com.liferay.portal.service.GroupService;
060    import com.liferay.portal.service.LayoutLocalService;
061    import com.liferay.portal.service.LayoutService;
062    import com.liferay.portal.service.OrganizationLocalService;
063    import com.liferay.portal.service.OrganizationService;
064    import com.liferay.portal.service.UserLocalService;
065    import com.liferay.portal.service.UserService;
066    import com.liferay.portal.service.permission.AccountPermissionUtil;
067    import com.liferay.portal.service.permission.CommonPermissionUtil;
068    import com.liferay.portal.service.permission.GroupPermissionUtil;
069    import com.liferay.portal.service.permission.LayoutPermissionUtil;
070    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
071    import com.liferay.portal.service.permission.PasswordPolicyPermissionUtil;
072    import com.liferay.portal.service.permission.PortalPermissionUtil;
073    import com.liferay.portal.service.permission.PortletPermissionUtil;
074    import com.liferay.portal.service.permission.RolePermissionUtil;
075    import com.liferay.portal.service.permission.UserGroupPermissionUtil;
076    import com.liferay.portal.service.permission.UserPermissionUtil;
077    import com.liferay.portal.theme.NavItem;
078    import com.liferay.portal.theme.ThemeDisplay;
079    import com.liferay.portal.util.PortalUtil;
080    import com.liferay.portal.util.SessionClicks_IW;
081    import com.liferay.portal.util.WebKeys;
082    import com.liferay.portal.webserver.WebServerServletTokenUtil;
083    import com.liferay.portlet.PortletURLFactoryUtil;
084    import com.liferay.portlet.dynamicdatamapping.util.DDMUtil;
085    import com.liferay.portlet.expando.service.ExpandoColumnLocalService;
086    import com.liferay.portlet.expando.service.ExpandoRowLocalService;
087    import com.liferay.portlet.expando.service.ExpandoTableLocalService;
088    import com.liferay.portlet.expando.service.ExpandoValueLocalService;
089    
090    import java.util.Collections;
091    import java.util.HashMap;
092    import java.util.List;
093    import java.util.Locale;
094    import java.util.Map;
095    import java.util.Set;
096    import java.util.concurrent.ConcurrentHashMap;
097    
098    import javax.portlet.PortletConfig;
099    import javax.portlet.PortletRequest;
100    import javax.portlet.PortletResponse;
101    import javax.portlet.RenderRequest;
102    import javax.portlet.RenderResponse;
103    
104    import javax.servlet.http.HttpServletRequest;
105    
106    import org.apache.struts.taglib.tiles.ComponentConstants;
107    import org.apache.struts.tiles.ComponentContext;
108    
109    /**
110     * @author Tina Tian
111     * @author Jorge Ferrer
112     * @author Raymond Aug??
113     */
114    public class TemplateContextHelper {
115    
116            public static Map<String, TemplateVariableGroup> getTemplateVariableGroups(
117                            long classNameId, long classPK, String language, Locale locale)
118                    throws Exception {
119    
120                    TemplateHandler templateHandler =
121                            TemplateHandlerRegistryUtil.getTemplateHandler(classNameId);
122    
123                    if (templateHandler == null) {
124                            return Collections.emptyMap();
125                    }
126    
127                    Map<String, TemplateVariableGroup> templateVariableGroups =
128                            templateHandler.getTemplateVariableGroups(
129                                    classPK, language, locale);
130    
131                    String[] restrictedVariables = templateHandler.getRestrictedVariables(
132                            language);
133    
134                    TemplateVariableGroup portalServicesTemplateVariableGroup =
135                            new TemplateVariableGroup("portal-services", restrictedVariables);
136    
137                    portalServicesTemplateVariableGroup.setAutocompleteEnabled(false);
138    
139                    portalServicesTemplateVariableGroup.addServiceLocatorVariables(
140                            GroupLocalService.class, GroupService.class,
141                            LayoutLocalService.class, LayoutService.class,
142                            OrganizationLocalService.class, OrganizationService.class,
143                            UserLocalService.class, UserService.class);
144    
145                    templateVariableGroups.put(
146                            portalServicesTemplateVariableGroup.getLabel(),
147                            portalServicesTemplateVariableGroup);
148    
149                    return templateVariableGroups;
150            }
151    
152            public Map<String, Object> getHelperUtilities(
153                    ClassLoader classLoader, boolean restricted) {
154    
155                    Map<String, Object>[] helperUtilitiesArray = _helperUtilitiesMaps.get(
156                            classLoader);
157    
158                    if (helperUtilitiesArray == null) {
159                            helperUtilitiesArray = (Map<String, Object>[])new Map<?, ?>[2];
160    
161                            _helperUtilitiesMaps.put(classLoader, helperUtilitiesArray);
162                    }
163                    else {
164                            Map<String, Object> helperUtilities = null;
165    
166                            if (restricted) {
167                                    helperUtilities = helperUtilitiesArray[1];
168                            }
169                            else {
170                                    helperUtilities = helperUtilitiesArray[0];
171                            }
172    
173                            if (helperUtilities != null) {
174                                    return helperUtilities;
175                            }
176                    }
177    
178                    Map<String, Object> helperUtilities = new HashMap<>();
179    
180                    populateCommonHelperUtilities(helperUtilities);
181                    populateExtraHelperUtilities(helperUtilities);
182    
183                    if (restricted) {
184                            Set<String> restrictedVariables = getRestrictedVariables();
185    
186                            for (String restrictedVariable : restrictedVariables) {
187                                    helperUtilities.remove(restrictedVariable);
188                            }
189    
190                            helperUtilitiesArray[1] = helperUtilities;
191                    }
192                    else {
193                            helperUtilitiesArray[0] = helperUtilities;
194                    }
195    
196                    return helperUtilities;
197            }
198    
199            public Set<String> getRestrictedVariables() {
200                    return Collections.emptySet();
201            }
202    
203            public TemplateControlContext getTemplateControlContext() {
204                    return _pacl.getTemplateControlContext();
205            }
206    
207            public void prepare(
208                    Map<String, Object> contextObjects, HttpServletRequest request) {
209    
210                    // Request
211    
212                    contextObjects.put("request", request);
213    
214                    // Portlet config
215    
216                    PortletConfig portletConfig = (PortletConfig)request.getAttribute(
217                            JavaConstants.JAVAX_PORTLET_CONFIG);
218    
219                    if (portletConfig != null) {
220                            contextObjects.put("portletConfig", portletConfig);
221                    }
222    
223                    // Render request
224    
225                    final PortletRequest portletRequest =
226                            (PortletRequest)request.getAttribute(
227                                    JavaConstants.JAVAX_PORTLET_REQUEST);
228    
229                    if (portletRequest != null) {
230                            if (portletRequest instanceof RenderRequest) {
231                                    contextObjects.put("renderRequest", portletRequest);
232                            }
233                    }
234    
235                    // Render response
236    
237                    final PortletResponse portletResponse =
238                            (PortletResponse)request.getAttribute(
239                                    JavaConstants.JAVAX_PORTLET_RESPONSE);
240    
241                    if (portletResponse != null) {
242                            if (portletResponse instanceof RenderResponse) {
243                                    contextObjects.put("renderResponse", portletResponse);
244                            }
245                    }
246    
247                    // XML request
248    
249                    if ((portletRequest != null) && (portletResponse != null)) {
250                            contextObjects.put(
251                                    "portletRequestModelFactory",
252                                    new PortletRequestModelFactory(
253                                            portletRequest, portletResponse));
254    
255                            // Deprecated
256    
257                            contextObjects.put(
258                                    "xmlRequest",
259                                    new Object() {
260    
261                                            @Override
262                                            public String toString() {
263                                                    PortletRequestModel portletRequestModel =
264                                                            new PortletRequestModel(
265                                                                    portletRequest, portletResponse);
266    
267                                                    return portletRequestModel.toXML();
268                                            }
269    
270                                    }
271                            );
272                    }
273    
274                    // Theme display
275    
276                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
277                            WebKeys.THEME_DISPLAY);
278    
279                    if (themeDisplay != null) {
280                            Layout layout = themeDisplay.getLayout();
281                            List<Layout> layouts = themeDisplay.getLayouts();
282    
283                            contextObjects.put("themeDisplay", themeDisplay);
284                            contextObjects.put("company", themeDisplay.getCompany());
285                            contextObjects.put("user", themeDisplay.getUser());
286                            contextObjects.put("realUser", themeDisplay.getRealUser());
287                            contextObjects.put("layout", layout);
288                            contextObjects.put("layouts", layouts);
289                            contextObjects.put("plid", String.valueOf(themeDisplay.getPlid()));
290                            contextObjects.put(
291                                    "layoutTypePortlet", themeDisplay.getLayoutTypePortlet());
292                            contextObjects.put(
293                                    "scopeGroupId", new Long(themeDisplay.getScopeGroupId()));
294                            contextObjects.put(
295                                    "permissionChecker", themeDisplay.getPermissionChecker());
296                            contextObjects.put("locale", themeDisplay.getLocale());
297                            contextObjects.put("timeZone", themeDisplay.getTimeZone());
298                            contextObjects.put("colorScheme", themeDisplay.getColorScheme());
299                            contextObjects.put(
300                                    "portletDisplay", themeDisplay.getPortletDisplay());
301    
302                            // Navigation items
303    
304                            if (layout != null) {
305                                    List<NavItem> navItems = NavItem.fromLayouts(
306                                            request, layouts, contextObjects);
307    
308                                    contextObjects.put("navItems", navItems);
309                            }
310    
311                            // Deprecated
312    
313                            contextObjects.put(
314                                    "portletGroupId", new Long(themeDisplay.getScopeGroupId()));
315                    }
316    
317                    // Theme
318    
319                    Theme theme = (Theme)request.getAttribute(WebKeys.THEME);
320    
321                    if ((theme == null) && (themeDisplay != null)) {
322                            theme = themeDisplay.getTheme();
323                    }
324    
325                    if (theme != null) {
326                            contextObjects.put("theme", theme);
327                    }
328    
329                    // Tiles attributes
330    
331                    prepareTiles(contextObjects, request);
332    
333                    // Page title and subtitle
334    
335                    ListMergeable<String> pageTitleListMergeable =
336                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_TITLE);
337    
338                    if (pageTitleListMergeable != null) {
339                            String pageTitle = pageTitleListMergeable.mergeToString(
340                                    StringPool.SPACE);
341    
342                            contextObjects.put("pageTitle", pageTitle);
343                    }
344    
345                    ListMergeable<String> pageSubtitleListMergeable =
346                            (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_SUBTITLE);
347    
348                    if (pageSubtitleListMergeable != null) {
349                            String pageSubtitle = pageSubtitleListMergeable.mergeToString(
350                                    StringPool.SPACE);
351    
352                            contextObjects.put("pageSubtitle", pageSubtitle);
353                    }
354            }
355    
356            public void removeAllHelperUtilities() {
357                    _helperUtilitiesMaps.clear();
358            }
359    
360            public void removeHelperUtilities(ClassLoader classLoader) {
361                    _helperUtilitiesMaps.remove(classLoader);
362            }
363    
364            public interface PACL {
365    
366                    public TemplateControlContext getTemplateControlContext();
367    
368            }
369    
370            protected void populateCommonHelperUtilities(
371                    Map<String, Object> variables) {
372    
373                    // Array util
374    
375                    variables.put("arrayUtil", ArrayUtil_IW.getInstance());
376    
377                    // Audit message factory
378    
379                    try {
380                            variables.put(
381                                    "auditMessageFactoryUtil",
382                                    AuditMessageFactoryUtil.getAuditMessageFactory());
383                    }
384                    catch (SecurityException se) {
385                            _log.error(se, se);
386                    }
387    
388                    // Audit router util
389    
390                    try {
391                            variables.put("auditRouterUtil", AuditRouterUtil.getAuditRouter());
392                    }
393                    catch (SecurityException se) {
394                            _log.error(se, se);
395                    }
396    
397                    // Browser sniffer
398    
399                    try {
400                            variables.put(
401                                    "browserSniffer", BrowserSnifferUtil.getBrowserSniffer());
402                    }
403                    catch (SecurityException se) {
404                            _log.error(se, se);
405                    }
406    
407                    // Calendar factory
408    
409                    try {
410                            variables.put(
411                                    "calendarFactory", CalendarFactoryUtil.getCalendarFactory());
412                    }
413                    catch (SecurityException se) {
414                            _log.error(se, se);
415                    }
416    
417                    // Date format
418    
419                    try {
420                            variables.put(
421                                    "dateFormatFactory",
422                                    FastDateFormatFactoryUtil.getFastDateFormatFactory());
423                    }
424                    catch (SecurityException se) {
425                            _log.error(se, se);
426                    }
427    
428                    // Date util
429    
430                    variables.put("dateUtil", DateUtil_IW.getInstance());
431    
432                    // Dynamic data mapping util
433    
434                    try {
435                            variables.put("ddmUtil", DDMUtil.getDDM());
436                    }
437                    catch (SecurityException se) {
438                            _log.error(se, se);
439                    }
440    
441                    // Expando column service
442    
443                    try {
444                            ServiceLocator serviceLocator = ServiceLocator.getInstance();
445    
446                            // Service locator
447    
448                            variables.put("serviceLocator", serviceLocator);
449    
450                            try {
451                                    variables.put(
452                                            "expandoColumnLocalService",
453                                            serviceLocator.findService(
454                                                    ExpandoColumnLocalService.class.getName()));
455                            }
456                            catch (SecurityException se) {
457                                    _log.error(se, se);
458                            }
459    
460                            // Expando row service
461    
462                            try {
463                                    variables.put(
464                                            "expandoRowLocalService",
465                                            serviceLocator.findService(
466                                                    ExpandoRowLocalService.class.getName()));
467                            }
468                            catch (SecurityException se) {
469                                    _log.error(se, se);
470                            }
471    
472                            // Expando table service
473    
474                            try {
475                                    variables.put(
476                                            "expandoTableLocalService",
477                                            serviceLocator.findService(
478                                                    ExpandoTableLocalService.class.getName()));
479                            }
480                            catch (SecurityException se) {
481                                    _log.error(se, se);
482                            }
483    
484                            // Expando value service
485    
486                            try {
487                                    variables.put(
488                                            "expandoValueLocalService",
489                                            serviceLocator.findService(
490                                                    ExpandoValueLocalService.class.getName()));
491                            }
492                            catch (SecurityException se) {
493                                    _log.error(se, se);
494                            }
495                    }
496                    catch (SecurityException se) {
497                            _log.error(se, se);
498                    }
499    
500                    // Getter util
501    
502                    variables.put("getterUtil", GetterUtil_IW.getInstance());
503    
504                    // Html util
505    
506                    try {
507                            variables.put("htmlUtil", HtmlUtil.getHtml());
508                    }
509                    catch (SecurityException se) {
510                            _log.error(se, se);
511                    }
512    
513                    // Http util
514    
515                    try {
516                            variables.put("httpUtil", HttpUtil.getHttp());
517                    }
518                    catch (SecurityException se) {
519                            _log.error(se, se);
520                    }
521    
522                    // Image tool util
523    
524                    try {
525                            variables.put("imageToolUtil", ImageToolUtil.getImageTool());
526                    }
527                    catch (SecurityException se) {
528                            _log.error(se, se);
529                    }
530    
531                    // JSON factory util
532    
533                    try {
534                            variables.put("jsonFactoryUtil", JSONFactoryUtil.getJSONFactory());
535                    }
536                    catch (SecurityException se) {
537                            _log.error(se, se);
538                    }
539    
540                    // Language util
541    
542                    try {
543                            variables.put("languageUtil", LanguageUtil.getLanguage());
544                    }
545                    catch (SecurityException se) {
546                            _log.error(se, se);
547                    }
548    
549                    try {
550                            variables.put(
551                                    "unicodeLanguageUtil",
552                                    UnicodeLanguageUtil.getUnicodeLanguage());
553                    }
554                    catch (SecurityException se) {
555                            _log.error(se, se);
556                    }
557    
558                    // Locale util
559    
560                    try {
561                            variables.put("localeUtil", LocaleUtil.getInstance());
562                    }
563                    catch (SecurityException se) {
564                            _log.error(se, se);
565                    }
566    
567                    // Param util
568    
569                    variables.put("paramUtil", ParamUtil_IW.getInstance());
570    
571                    // Portal util
572    
573                    try {
574                            variables.put("portalUtil", PortalUtil.getPortal());
575                    }
576                    catch (SecurityException se) {
577                            _log.error(se, se);
578                    }
579    
580                    try {
581                            variables.put("portal", PortalUtil.getPortal());
582                    }
583                    catch (SecurityException se) {
584                            _log.error(se, se);
585                    }
586    
587                    // Prefs props util
588    
589                    try {
590                            variables.put("prefsPropsUtil", PrefsPropsUtil.getPrefsProps());
591                    }
592                    catch (SecurityException se) {
593                            _log.error(se, se);
594                    }
595    
596                    // Props util
597    
598                    try {
599                            variables.put("propsUtil", PropsUtil.getProps());
600                    }
601                    catch (SecurityException se) {
602                            _log.error(se, se);
603                    }
604    
605                    // Portlet mode factory
606    
607                    variables.put(
608                            "portletModeFactory", PortletModeFactory_IW.getInstance());
609    
610                    // Portlet URL factory
611    
612                    try {
613                            variables.put(
614                                    "portletURLFactory",
615                                    PortletURLFactoryUtil.getPortletURLFactory());
616                    }
617                    catch (SecurityException se) {
618                            _log.error(se, se);
619                    }
620    
621                    try {
622                            UtilLocator utilLocator = UtilLocator.getInstance();
623    
624                            // Util locator
625    
626                            variables.put("utilLocator", utilLocator);
627    
628                            // SAX reader util
629    
630                            try {
631                                    variables.put(
632                                            "saxReaderUtil",
633                                            utilLocator.findUtil(SAXReaderUtil.class.getName()));
634                            }
635                            catch (SecurityException se) {
636                                    _log.error(se, se);
637                            }
638                    }
639                    catch (SecurityException se) {
640                            _log.error(se, se);
641                    }
642    
643                    // Session clicks
644    
645                    variables.put("sessionClicks", SessionClicks_IW.getInstance());
646    
647                    // Static field getter
648    
649                    variables.put("staticFieldGetter", StaticFieldGetter.getInstance());
650    
651                    // String util
652    
653                    variables.put("stringUtil", StringUtil_IW.getInstance());
654    
655                    // Time zone util
656    
657                    variables.put("timeZoneUtil", TimeZoneUtil_IW.getInstance());
658    
659                    // Unicode formatter
660    
661                    variables.put("unicodeFormatter", UnicodeFormatter_IW.getInstance());
662    
663                    // Validator
664    
665                    variables.put("validator", Validator_IW.getInstance());
666    
667                    // Web server servlet token
668    
669                    try {
670                            variables.put(
671                                    "webServerToken",
672                                    WebServerServletTokenUtil.getWebServerServletToken());
673                    }
674                    catch (SecurityException se) {
675                            _log.error(se, se);
676                    }
677    
678                    // Window state factory
679    
680                    variables.put(
681                            "windowStateFactory", WindowStateFactory_IW.getInstance());
682    
683                    // Permissions
684    
685                    try {
686                            variables.put(
687                                    "accountPermission",
688                                    AccountPermissionUtil.getAccountPermission());
689                    }
690                    catch (SecurityException se) {
691                            _log.error(se, se);
692                    }
693    
694                    try {
695                            variables.put(
696                                    "commonPermission", CommonPermissionUtil.getCommonPermission());
697                    }
698                    catch (SecurityException se) {
699                            _log.error(se, se);
700                    }
701    
702                    try {
703                            variables.put(
704                                    "groupPermission", GroupPermissionUtil.getGroupPermission());
705                    }
706                    catch (SecurityException se) {
707                            _log.error(se, se);
708                    }
709    
710                    try {
711                            variables.put(
712                                    "layoutPermission", LayoutPermissionUtil.getLayoutPermission());
713                    }
714                    catch (SecurityException se) {
715                            _log.error(se, se);
716                    }
717    
718                    try {
719                            variables.put(
720                                    "organizationPermission",
721                                    OrganizationPermissionUtil.getOrganizationPermission());
722                    }
723                    catch (SecurityException se) {
724                            _log.error(se, se);
725                    }
726    
727                    try {
728                            variables.put(
729                                    "passwordPolicyPermission",
730                                    PasswordPolicyPermissionUtil.getPasswordPolicyPermission());
731                    }
732                    catch (SecurityException se) {
733                            _log.error(se, se);
734                    }
735    
736                    try {
737                            variables.put(
738                                    "portalPermission", PortalPermissionUtil.getPortalPermission());
739                    }
740                    catch (SecurityException se) {
741                            _log.error(se, se);
742                    }
743    
744                    try {
745                            variables.put(
746                                    "portletPermission",
747                                    PortletPermissionUtil.getPortletPermission());
748                    }
749                    catch (SecurityException se) {
750                            _log.error(se, se);
751                    }
752    
753                    Map<String, PortletProvider.Action> portletProviderActionMap =
754                            new HashMap<>();
755    
756                    for (PortletProvider.Action action : PortletProvider.Action.values()) {
757                            portletProviderActionMap.put(action.name(), action);
758                    }
759    
760                    try {
761                            variables.put("portletProviderAction", portletProviderActionMap);
762                    }
763                    catch (SecurityException se) {
764                            _log.error(se, se);
765                    }
766    
767                    try {
768                            variables.put(
769                                    "rolePermission", RolePermissionUtil.getRolePermission());
770                    }
771                    catch (SecurityException se) {
772                            _log.error(se, se);
773                    }
774    
775                    try {
776                            variables.put(
777                                    "userGroupPermission",
778                                    UserGroupPermissionUtil.getUserGroupPermission());
779                    }
780                    catch (SecurityException se) {
781                            _log.error(se, se);
782                    }
783    
784                    try {
785                            variables.put(
786                                    "userPermission", UserPermissionUtil.getUserPermission());
787                    }
788                    catch (SecurityException se) {
789                            _log.error(se, se);
790                    }
791    
792                    // Deprecated
793    
794                    populateDeprecatedCommonHelperUtilities(variables);
795            }
796    
797            @SuppressWarnings("deprecation")
798            protected void populateDeprecatedCommonHelperUtilities(
799                    Map<String, Object> variables) {
800    
801                    try {
802                            variables.put(
803                                    "dateFormats",
804                                    FastDateFormatFactoryUtil.getFastDateFormatFactory());
805                    }
806                    catch (SecurityException se) {
807                            _log.error(se, se);
808                    }
809    
810                    try {
811                            variables.put(
812                                    "imageToken",
813                                    WebServerServletTokenUtil.getWebServerServletToken());
814                    }
815                    catch (SecurityException se) {
816                            _log.error(se, se);
817                    }
818    
819                    try {
820                            variables.put(
821                                    "locationPermission",
822                                    OrganizationPermissionUtil.getOrganizationPermission());
823                    }
824                    catch (SecurityException se) {
825                            _log.error(se, se);
826                    }
827    
828                    try {
829                            com.liferay.portal.kernel.util.Randomizer_IW randomizer =
830                                    com.liferay.portal.kernel.util.Randomizer_IW.getInstance();
831    
832                            variables.put("randomizer", randomizer.getWrappedInstance());
833                    }
834                    catch (SecurityException se) {
835                            _log.error(se, se);
836                    }
837            }
838    
839            protected void populateExtraHelperUtilities(Map<String, Object> variables) {
840            }
841    
842            protected void prepareTiles(
843                    Map<String, Object> contextObjects, HttpServletRequest request) {
844    
845                    ComponentContext componentContext =
846                            (ComponentContext)request.getAttribute(
847                                    ComponentConstants.COMPONENT_CONTEXT);
848    
849                    if (componentContext == null) {
850                            return;
851                    }
852    
853                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
854                            WebKeys.THEME_DISPLAY);
855    
856                    String tilesTitle = (String)componentContext.getAttribute("title");
857    
858                    themeDisplay.setTilesTitle(tilesTitle);
859    
860                    contextObjects.put("tilesTitle", tilesTitle);
861    
862                    String tilesContent = (String)componentContext.getAttribute("content");
863    
864                    themeDisplay.setTilesContent(tilesContent);
865    
866                    contextObjects.put("tilesContent", tilesContent);
867    
868                    boolean tilesSelectable = GetterUtil.getBoolean(
869                            (String)componentContext.getAttribute("selectable"));
870    
871                    themeDisplay.setTilesSelectable(tilesSelectable);
872    
873                    contextObjects.put("tilesSelectable", tilesSelectable);
874            }
875    
876            private static final Log _log = LogFactoryUtil.getLog(
877                    TemplateContextHelper.class);
878    
879            private static final PACL _pacl = new NoPACL();
880    
881            private final Map<ClassLoader, Map<String, Object>[]> _helperUtilitiesMaps =
882                    new ConcurrentHashMap<>();
883    
884            private static class NoPACL implements PACL {
885    
886                    @Override
887                    public TemplateControlContext getTemplateControlContext() {
888                            ClassLoader contextClassLoader =
889                                    ClassLoaderUtil.getContextClassLoader();
890    
891                            return new TemplateControlContext(null, contextClassLoader);
892                    }
893    
894            }
895    
896    }