001
014
015 package com.liferay.portal.templateparser;
016
017 import com.liferay.portal.kernel.configuration.Filter;
018 import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
019 import com.liferay.portal.kernel.log.Log;
020 import com.liferay.portal.kernel.log.LogFactoryUtil;
021 import com.liferay.portal.kernel.mobile.device.Device;
022 import com.liferay.portal.kernel.mobile.device.UnknownDevice;
023 import com.liferay.portal.kernel.servlet.GenericServletWrapper;
024 import com.liferay.portal.kernel.servlet.PipingServletResponse;
025 import com.liferay.portal.kernel.template.StringTemplateResource;
026 import com.liferay.portal.kernel.template.Template;
027 import com.liferay.portal.kernel.template.TemplateConstants;
028 import com.liferay.portal.kernel.template.TemplateManagerUtil;
029 import com.liferay.portal.kernel.template.TemplateResource;
030 import com.liferay.portal.kernel.template.URLTemplateResource;
031 import com.liferay.portal.kernel.templateparser.TemplateNode;
032 import com.liferay.portal.kernel.templateparser.TransformException;
033 import com.liferay.portal.kernel.templateparser.TransformerListener;
034 import com.liferay.portal.kernel.util.Constants;
035 import com.liferay.portal.kernel.util.GetterUtil;
036 import com.liferay.portal.kernel.util.InstanceFactory;
037 import com.liferay.portal.kernel.util.LocaleUtil;
038 import com.liferay.portal.kernel.util.LocalizationUtil;
039 import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
040 import com.liferay.portal.kernel.util.PropertiesUtil;
041 import com.liferay.portal.kernel.util.SetUtil;
042 import com.liferay.portal.kernel.util.StringBundler;
043 import com.liferay.portal.kernel.util.StringPool;
044 import com.liferay.portal.kernel.util.StringUtil;
045 import com.liferay.portal.kernel.util.Validator;
046 import com.liferay.portal.kernel.xml.Document;
047 import com.liferay.portal.kernel.xml.DocumentException;
048 import com.liferay.portal.kernel.xml.Element;
049 import com.liferay.portal.kernel.xml.SAXReaderUtil;
050 import com.liferay.portal.model.Company;
051 import com.liferay.portal.security.permission.PermissionThreadLocal;
052 import com.liferay.portal.service.CompanyLocalServiceUtil;
053 import com.liferay.portal.theme.ThemeDisplay;
054 import com.liferay.portal.util.PropsUtil;
055 import com.liferay.portal.xsl.XSLTemplateResource;
056 import com.liferay.portal.xsl.XSLURIResolver;
057 import com.liferay.portlet.journal.util.JournalXSLURIResolver;
058 import com.liferay.portlet.portletdisplaytemplate.util.PortletDisplayTemplateConstants;
059 import com.liferay.taglib.util.VelocityTaglib;
060 import com.liferay.taglib.util.VelocityTaglibImpl;
061 import com.liferay.util.freemarker.FreeMarkerTaglibFactoryUtil;
062
063 import freemarker.ext.servlet.HttpRequestHashModel;
064 import freemarker.ext.servlet.ServletContextHashModel;
065
066 import freemarker.template.ObjectWrapper;
067 import freemarker.template.TemplateHashModel;
068
069 import java.io.IOException;
070
071 import java.net.URL;
072
073 import java.util.ArrayList;
074 import java.util.HashMap;
075 import java.util.HashSet;
076 import java.util.List;
077 import java.util.Locale;
078 import java.util.Map;
079 import java.util.Set;
080
081 import javax.servlet.GenericServlet;
082 import javax.servlet.Servlet;
083 import javax.servlet.ServletContext;
084 import javax.servlet.http.HttpServletRequest;
085 import javax.servlet.http.HttpServletResponse;
086 import javax.servlet.http.HttpSession;
087 import javax.servlet.jsp.PageContext;
088
089
099 public class Transformer {
100
101 public Transformer(String errorTemplatePropertyKey, boolean restricted) {
102 Set<String> langTypes = TemplateManagerUtil.getSupportedLanguageTypes(
103 errorTemplatePropertyKey);
104
105 for (String langType : langTypes) {
106 String errorTemplateId = PropsUtil.get(
107 errorTemplatePropertyKey, new Filter(langType));
108
109 if (Validator.isNotNull(errorTemplateId)) {
110 _errorTemplateIds.put(langType, errorTemplateId);
111 }
112 }
113
114 _restricted = restricted;
115 }
116
117 public Transformer(
118 String transformerListenerPropertyKey, String errorTemplatePropertyKey,
119 boolean restricted) {
120
121 this(errorTemplatePropertyKey, restricted);
122
123 _transformerListenerClassNames = SetUtil.fromArray(
124 PropsUtil.getArray(transformerListenerPropertyKey));
125 }
126
127 public String transform(
128 ThemeDisplay themeDisplay, Map<String, Object> contextObjects,
129 String script, String langType)
130 throws Exception {
131
132 return transform(null, themeDisplay, contextObjects, script, langType);
133 }
134
135 public String transform(
136 PageContext pageContext, ThemeDisplay themeDisplay,
137 Map<String, Object> contextObjects, String script, String langType)
138 throws Exception {
139
140 if (Validator.isNull(langType)) {
141 return null;
142 }
143
144
145
146 if (pageContext != null) {
147 if (langType.equals(TemplateConstants.LANG_TYPE_FTL)) {
148 _addTaglibSupportFTL(contextObjects, pageContext);
149 }
150 else if (langType.equals(TemplateConstants.LANG_TYPE_VM)) {
151 _addTaglibSupportVM(contextObjects, pageContext);
152 }
153 }
154
155 long companyId = 0;
156 long companyGroupId = 0;
157 long scopeGroupId = 0;
158 long siteGroupId = 0;
159
160 if (themeDisplay != null) {
161 companyId = themeDisplay.getCompanyId();
162 companyGroupId = themeDisplay.getCompanyGroupId();
163 scopeGroupId = themeDisplay.getScopeGroupId();
164 siteGroupId = themeDisplay.getSiteGroupId();
165 }
166
167 String templateId = String.valueOf(contextObjects.get("template_id"));
168
169 templateId = getTemplateId(
170 templateId, companyId, companyGroupId, scopeGroupId);
171
172 Template template = getTemplate(templateId, script, langType);
173
174 UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
175
176 try {
177 prepareTemplate(themeDisplay, template);
178
179 long classNameId = 0;
180
181 if (contextObjects != null) {
182 for (String key : contextObjects.keySet()) {
183 template.put(key, contextObjects.get(key));
184 }
185
186 classNameId = GetterUtil.getLong(
187 contextObjects.get(TemplateConstants.CLASS_NAME_ID));
188 }
189
190 template.put("company", getCompany(themeDisplay, companyId));
191 template.put("companyId", companyId);
192 template.put("device", getDevice(themeDisplay));
193
194 String templatesPath = getTemplatesPath(
195 companyId, scopeGroupId, classNameId);
196
197 template.put("journalTemplatesPath", templatesPath);
198 template.put(
199 "permissionChecker",
200 PermissionThreadLocal.getPermissionChecker());
201 template.put(
202 "randomNamespace",
203 StringUtil.randomId() + StringPool.UNDERLINE);
204 template.put("scopeGroupId", scopeGroupId);
205 template.put("siteGroupId", siteGroupId);
206 template.put("templatesPath", templatesPath);
207
208
209
210 template.put("groupId", scopeGroupId);
211
212 mergeTemplate(template, unsyncStringWriter);
213 }
214 catch (Exception e) {
215 throw new TransformException("Unhandled exception", e);
216 }
217
218 return unsyncStringWriter.toString();
219 }
220
221 public String transform(
222 ThemeDisplay themeDisplay, Map<String, String> tokens,
223 String viewMode, String languageId, String xml, String script,
224 String langType)
225 throws Exception {
226
227
228
229 if (_log.isDebugEnabled()) {
230 _log.debug("Language " + languageId);
231 }
232
233 if (Validator.isNull(viewMode)) {
234 viewMode = Constants.VIEW;
235 }
236
237 if (_logTokens.isDebugEnabled()) {
238 String tokensString = PropertiesUtil.list(tokens);
239
240 _logTokens.debug(tokensString);
241 }
242
243 if (_logTransformBefore.isDebugEnabled()) {
244 _logTransformBefore.debug(xml);
245 }
246
247 List<TransformerListener> transformerListeners =
248 new ArrayList<TransformerListener>();
249
250 for (String transformerListenersClassName :
251 _transformerListenerClassNames) {
252
253 TransformerListener transformerListener = null;
254
255 try {
256 if (_log.isDebugEnabled()) {
257 _log.debug(
258 "Instantiate listener " +
259 transformerListenersClassName);
260 }
261
262 ClassLoader classLoader =
263 PortalClassLoaderUtil.getClassLoader();
264
265 transformerListener =
266 (TransformerListener)InstanceFactory.newInstance(
267 classLoader, transformerListenersClassName);
268
269 transformerListeners.add(transformerListener);
270 }
271 catch (Exception e) {
272 _log.error(e, e);
273 }
274
275
276
277 if (_logXmlBeforeListener.isDebugEnabled()) {
278 _logXmlBeforeListener.debug(xml);
279 }
280
281 if (transformerListener != null) {
282 xml = transformerListener.onXml(xml, languageId, tokens);
283
284 if (_logXmlAfterListener.isDebugEnabled()) {
285 _logXmlAfterListener.debug(xml);
286 }
287 }
288
289
290
291 if (_logScriptBeforeListener.isDebugEnabled()) {
292 _logScriptBeforeListener.debug(script);
293 }
294
295 if (transformerListener != null) {
296 script = transformerListener.onScript(
297 script, xml, languageId, tokens);
298
299 if (_logScriptAfterListener.isDebugEnabled()) {
300 _logScriptAfterListener.debug(script);
301 }
302 }
303 }
304
305
306
307 String output = null;
308
309 if (Validator.isNull(langType)) {
310 output = LocalizationUtil.getLocalization(xml, languageId);
311 }
312 else {
313 long companyId = 0;
314 long companyGroupId = 0;
315 long articleGroupId = 0;
316 long classNameId = 0;
317
318 if (tokens != null) {
319 companyId = GetterUtil.getLong(tokens.get("company_id"));
320 companyGroupId = GetterUtil.getLong(
321 tokens.get("company_group_id"));
322 articleGroupId = GetterUtil.getLong(
323 tokens.get("article_group_id"));
324 classNameId = GetterUtil.getLong(
325 tokens.get(TemplateConstants.CLASS_NAME_ID));
326 }
327
328 long scopeGroupId = 0;
329 long siteGroupId = 0;
330
331 if (themeDisplay != null) {
332 companyId = themeDisplay.getCompanyId();
333 companyGroupId = themeDisplay.getCompanyGroupId();
334 scopeGroupId = themeDisplay.getScopeGroupId();
335 siteGroupId = themeDisplay.getSiteGroupId();
336 }
337
338 String templateId = tokens.get("template_id");
339
340 templateId = getTemplateId(
341 templateId, companyId, companyGroupId, articleGroupId);
342
343 Template template = getTemplate(
344 templateId, tokens, languageId, xml, script, langType);
345
346 UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
347
348 try {
349 if (Validator.isNotNull(xml)) {
350 Document document = SAXReaderUtil.read(xml);
351
352 Element rootElement = document.getRootElement();
353
354 List<TemplateNode> templateNodes = getTemplateNodes(
355 themeDisplay, rootElement);
356
357 if (templateNodes != null) {
358 for (TemplateNode templateNode : templateNodes) {
359 template.put(templateNode.getName(), templateNode);
360 }
361 }
362
363 Element requestElement = rootElement.element("request");
364
365 template.put(
366 "request", insertRequestVariables(requestElement));
367
368 template.put("xmlRequest", requestElement.asXML());
369 }
370
371 template.put("articleGroupId", articleGroupId);
372 template.put("company", getCompany(themeDisplay, companyId));
373 template.put("companyId", companyId);
374 template.put("device", getDevice(themeDisplay));
375
376 String templatesPath = getTemplatesPath(
377 companyId, articleGroupId, classNameId);
378
379 template.put("journalTemplatesPath", templatesPath);
380
381 Locale locale = LocaleUtil.fromLanguageId(languageId);
382
383 template.put("locale", locale);
384
385 template.put(
386 "permissionChecker",
387 PermissionThreadLocal.getPermissionChecker());
388 template.put(
389 "randomNamespace",
390 StringUtil.randomId() + StringPool.UNDERLINE);
391 template.put("scopeGroupId", scopeGroupId);
392 template.put("siteGroupId", siteGroupId);
393 template.put("templatesPath", templatesPath);
394 template.put("viewMode", viewMode);
395
396
397
398 template.put("groupId", articleGroupId);
399
400 mergeTemplate(template, unsyncStringWriter);
401 }
402 catch (Exception e) {
403 if (e instanceof DocumentException) {
404 throw new TransformException(
405 "Unable to read XML document", e);
406 }
407 else if (e instanceof IOException) {
408 throw new TransformException("Error reading template", e);
409 }
410 else if (e instanceof TransformException) {
411 throw (TransformException)e;
412 }
413 else {
414 throw new TransformException("Unhandled exception", e);
415 }
416 }
417
418 output = unsyncStringWriter.toString();
419 }
420
421
422
423 for (TransformerListener transformerListener : transformerListeners) {
424
425
426
427 if (_logOutputBeforeListener.isDebugEnabled()) {
428 _logOutputBeforeListener.debug(output);
429 }
430
431 output = transformerListener.onOutput(output, languageId, tokens);
432
433 if (_logOutputAfterListener.isDebugEnabled()) {
434 _logOutputAfterListener.debug(output);
435 }
436 }
437
438 if (_logTransfromAfter.isDebugEnabled()) {
439 _logTransfromAfter.debug(output);
440 }
441
442 return output;
443 }
444
445 protected Company getCompany(ThemeDisplay themeDisplay, long companyId)
446 throws Exception {
447
448 if (themeDisplay != null) {
449 return themeDisplay.getCompany();
450 }
451
452 return CompanyLocalServiceUtil.getCompany(companyId);
453 }
454
455 protected Device getDevice(ThemeDisplay themeDisplay) {
456 if (themeDisplay != null) {
457 return themeDisplay.getDevice();
458 }
459
460 return UnknownDevice.getInstance();
461 }
462
463 protected TemplateResource getErrorTemplateResource(String langType) {
464 try {
465 Class<?> clazz = getClass();
466
467 ClassLoader classLoader = clazz.getClassLoader();
468
469 String errorTemplateId = _errorTemplateIds.get(langType);
470
471 URL url = classLoader.getResource(errorTemplateId);
472
473 return new URLTemplateResource(errorTemplateId, url);
474 }
475 catch (Exception e) {
476 }
477
478 return null;
479 }
480
481 protected Template getTemplate(
482 String templateId, Map<String, String> tokens, String languageId,
483 String xml, String script, String langType)
484 throws Exception {
485
486 TemplateResource templateResource = null;
487
488 if (langType.equals(TemplateConstants.LANG_TYPE_XSL)) {
489 XSLURIResolver xslURIResolver = new JournalXSLURIResolver(
490 tokens, languageId);
491
492 templateResource = new XSLTemplateResource(
493 templateId, script, xslURIResolver, xml);
494 }
495 else {
496 templateResource = new StringTemplateResource(templateId, script);
497 }
498
499 TemplateResource errorTemplateResource = getErrorTemplateResource(
500 langType);
501
502 return TemplateManagerUtil.getTemplate(
503 langType, templateResource, errorTemplateResource, _restricted);
504 }
505
506 protected Template getTemplate(
507 String templateId, String script, String langType)
508 throws Exception {
509
510 TemplateResource templateResource = new StringTemplateResource(
511 templateId, script);
512
513 TemplateResource errorTemplateResource = getErrorTemplateResource(
514 langType);
515
516 return TemplateManagerUtil.getTemplate(
517 langType, templateResource, errorTemplateResource, _restricted);
518 }
519
520 protected String getTemplateId(
521 String templateId, long companyId, long companyGroupId, long groupId) {
522
523 StringBundler sb = new StringBundler(5);
524
525 sb.append(companyId);
526 sb.append(StringPool.POUND);
527
528 if (companyGroupId > 0) {
529 sb.append(companyGroupId);
530 }
531 else {
532 sb.append(groupId);
533 }
534
535 sb.append(StringPool.POUND);
536 sb.append(templateId);
537
538 return sb.toString();
539 }
540
541 protected List<TemplateNode> getTemplateNodes(
542 ThemeDisplay themeDisplay, Element element)
543 throws Exception {
544
545 List<TemplateNode> templateNodes = new ArrayList<TemplateNode>();
546
547 Map<String, TemplateNode> prototypeTemplateNodes =
548 new HashMap<String, TemplateNode>();
549
550 List<Element> dynamicElementElements = element.elements(
551 "dynamic-element");
552
553 for (Element dynamicElementElement : dynamicElementElements) {
554 Element dynamicContentElement = dynamicElementElement.element(
555 "dynamic-content");
556
557 String data = StringPool.BLANK;
558
559 if (dynamicContentElement != null) {
560 data = dynamicContentElement.getText();
561 }
562
563 String name = dynamicElementElement.attributeValue(
564 "name", StringPool.BLANK);
565
566 if (name.length() == 0) {
567 throw new TransformException(
568 "Element missing \"name\" attribute");
569 }
570
571 String type = dynamicElementElement.attributeValue(
572 "type", StringPool.BLANK);
573
574 TemplateNode templateNode = new TemplateNode(
575 themeDisplay, name, stripCDATA(data), type);
576
577 if (dynamicElementElement.element("dynamic-element") != null) {
578 templateNode.appendChildren(
579 getTemplateNodes(themeDisplay, dynamicElementElement));
580 }
581 else if ((dynamicContentElement != null) &&
582 (dynamicContentElement.element("option") != null)) {
583
584 List<Element> optionElements = dynamicContentElement.elements(
585 "option");
586
587 for (Element optionElement : optionElements) {
588 templateNode.appendOption(
589 stripCDATA(optionElement.getText()));
590 }
591 }
592
593 TemplateNode prototypeTemplateNode = prototypeTemplateNodes.get(
594 name);
595
596 if (prototypeTemplateNode == null) {
597 prototypeTemplateNode = templateNode;
598
599 prototypeTemplateNodes.put(name, prototypeTemplateNode);
600
601 templateNodes.add(templateNode);
602 }
603
604 prototypeTemplateNode.appendSibling(templateNode);
605 }
606
607 return templateNodes;
608 }
609
610 protected String getTemplatesPath(
611 long companyId, long groupId, long classNameId) {
612
613 StringBundler sb = new StringBundler(7);
614
615 sb.append(TemplateConstants.TEMPLATE_SEPARATOR);
616 sb.append(StringPool.SLASH);
617 sb.append(companyId);
618 sb.append(StringPool.SLASH);
619 sb.append(groupId);
620 sb.append(StringPool.SLASH);
621 sb.append(classNameId);
622
623 return sb.toString();
624 }
625
626 protected Map<String, Object> insertRequestVariables(Element element) {
627 Map<String, Object> map = new HashMap<String, Object>();
628
629 if (element == null) {
630 return map;
631 }
632
633 for (Element childElement : element.elements()) {
634 String name = childElement.getName();
635
636 if (name.equals("attribute")) {
637 Element nameElement = childElement.element("name");
638 Element valueElement = childElement.element("value");
639
640 map.put(nameElement.getText(), valueElement.getText());
641 }
642 else if (name.equals("parameter")) {
643 Element nameElement = childElement.element("name");
644
645 List<Element> valueElements = childElement.elements("value");
646
647 if (valueElements.size() == 1) {
648 Element valueElement = valueElements.get(0);
649
650 map.put(nameElement.getText(), valueElement.getText());
651 }
652 else {
653 List<String> values = new ArrayList<String>();
654
655 for (Element valueElement : valueElements) {
656 values.add(valueElement.getText());
657 }
658
659 map.put(nameElement.getText(), values);
660 }
661 }
662 else {
663 List<Element> elements = childElement.elements();
664
665 if (!elements.isEmpty()) {
666 map.put(name, insertRequestVariables(childElement));
667 }
668 else {
669 map.put(name, childElement.getText());
670 }
671 }
672 }
673
674 return map;
675 }
676
677 protected void mergeTemplate(
678 Template template, UnsyncStringWriter unsyncStringWriter)
679 throws Exception {
680
681 VelocityTaglib velocityTaglib = (VelocityTaglib)template.get(
682 PortletDisplayTemplateConstants.TAGLIB_LIFERAY);
683
684 if (velocityTaglib != null) {
685 velocityTaglib.setTemplate(template);
686 }
687
688 template.processTemplate(unsyncStringWriter);
689 }
690
691 protected void prepareTemplate(ThemeDisplay themeDisplay, Template template)
692 throws Exception {
693
694 if (themeDisplay == null) {
695 return;
696 }
697
698 template.prepare(themeDisplay.getRequest());
699 }
700
701 protected String stripCDATA(String s) {
702 if (s.startsWith(StringPool.CDATA_OPEN) &&
703 s.endsWith(StringPool.CDATA_CLOSE)) {
704
705 s = s.substring(
706 StringPool.CDATA_OPEN.length(),
707 s.length() - StringPool.CDATA_CLOSE.length());
708 }
709
710 return s;
711 }
712
713 private void _addTaglibSupportFTL(
714 Map<String, Object> contextObjects, PageContext pageContext)
715 throws Exception {
716
717
718
719 final Servlet servlet = (Servlet)pageContext.getPage();
720
721 GenericServlet genericServlet = null;
722
723 if (servlet instanceof GenericServlet) {
724 genericServlet = (GenericServlet)servlet;
725 }
726 else {
727 genericServlet = new GenericServletWrapper(servlet);
728
729 genericServlet.init(pageContext.getServletConfig());
730 }
731
732 ServletContextHashModel servletContextHashModel =
733 new ServletContextHashModel(
734 genericServlet, ObjectWrapper.DEFAULT_WRAPPER);
735
736 contextObjects.put(
737 PortletDisplayTemplateConstants.FREEMARKER_SERVLET_APPLICATION,
738 servletContextHashModel);
739
740
741
742 HttpServletRequest request =
743 (HttpServletRequest)pageContext.getRequest();
744 HttpServletResponse response =
745 (HttpServletResponse)pageContext.getResponse();
746
747 HttpRequestHashModel requestHashModel = new HttpRequestHashModel(
748 request, response, ObjectWrapper.DEFAULT_WRAPPER);
749
750 contextObjects.put(
751 PortletDisplayTemplateConstants.FREEMARKER_SERVLET_REQUEST,
752 requestHashModel);
753
754
755
756 TemplateHashModel taglibLiferayHash =
757 FreeMarkerTaglibFactoryUtil.createTaglibFactory(
758 pageContext.getServletContext());
759
760 contextObjects.put(
761 PortletDisplayTemplateConstants.TAGLIB_LIFERAY_HASH,
762 taglibLiferayHash);
763 }
764
765 private void _addTaglibSupportVM(
766 Map<String, Object> contextObjects, PageContext pageContext) {
767
768 contextObjects.put(
769 PortletDisplayTemplateConstants.TAGLIB_LIFERAY,
770 _getVelocityTaglib(pageContext));
771 }
772
773 private VelocityTaglib _getVelocityTaglib(PageContext pageContext) {
774 HttpServletRequest request =
775 (HttpServletRequest)pageContext.getRequest();
776
777 HttpSession session = request.getSession();
778
779 ServletContext servletContext = session.getServletContext();
780
781 HttpServletResponse response =
782 (HttpServletResponse)pageContext.getResponse();
783
784 VelocityTaglib velocityTaglib = new VelocityTaglibImpl(
785 servletContext, request,
786 new PipingServletResponse(response, pageContext.getOut()),
787 pageContext, null);
788
789 return velocityTaglib;
790 }
791
792 private static Log _log = LogFactoryUtil.getLog(Transformer.class);
793
794 private static Log _logOutputAfterListener = LogFactoryUtil.getLog(
795 Transformer.class.getName() + ".OutputAfterListener");
796 private static Log _logOutputBeforeListener = LogFactoryUtil.getLog(
797 Transformer.class.getName() + ".OutputBeforeListener");
798 private static Log _logScriptAfterListener = LogFactoryUtil.getLog(
799 Transformer.class.getName() + ".ScriptAfterListener");
800 private static Log _logScriptBeforeListener = LogFactoryUtil.getLog(
801 Transformer.class.getName() + ".ScriptBeforeListener");
802 private static Log _logTokens = LogFactoryUtil.getLog(
803 Transformer.class.getName() + ".Tokens");
804 private static Log _logTransformBefore = LogFactoryUtil.getLog(
805 Transformer.class.getName() + ".TransformBefore");
806 private static Log _logTransfromAfter = LogFactoryUtil.getLog(
807 Transformer.class.getName() + ".TransformAfter");
808 private static Log _logXmlAfterListener = LogFactoryUtil.getLog(
809 Transformer.class.getName() + ".XmlAfterListener");
810 private static Log _logXmlBeforeListener = LogFactoryUtil.getLog(
811 Transformer.class.getName() + ".XmlBeforeListener");
812
813 private Map<String, String> _errorTemplateIds =
814 new HashMap<String, String>();
815 private boolean _restricted;
816 private Set<String> _transformerListenerClassNames = new HashSet<String>();
817
818 }