001    /**
002     * Copyright (c) 2000-2012 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.portlet.dynamicdatamapping.util;
016    
017    import com.liferay.portal.kernel.freemarker.FreeMarkerContext;
018    import com.liferay.portal.kernel.freemarker.FreeMarkerEngineUtil;
019    import com.liferay.portal.kernel.freemarker.FreeMarkerVariablesUtil;
020    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
021    import com.liferay.portal.kernel.json.JSONArray;
022    import com.liferay.portal.kernel.json.JSONException;
023    import com.liferay.portal.kernel.json.JSONFactoryUtil;
024    import com.liferay.portal.kernel.json.JSONObject;
025    import com.liferay.portal.kernel.util.ArrayUtil;
026    import com.liferay.portal.kernel.util.CharPool;
027    import com.liferay.portal.kernel.util.GetterUtil;
028    import com.liferay.portal.kernel.util.LocaleUtil;
029    import com.liferay.portal.kernel.util.LocalizationUtil;
030    import com.liferay.portal.kernel.util.StringBundler;
031    import com.liferay.portal.kernel.util.StringPool;
032    import com.liferay.portal.kernel.util.StringUtil;
033    import com.liferay.portal.kernel.util.Validator;
034    import com.liferay.portal.kernel.xml.Attribute;
035    import com.liferay.portal.kernel.xml.Document;
036    import com.liferay.portal.kernel.xml.DocumentException;
037    import com.liferay.portal.kernel.xml.Element;
038    import com.liferay.portal.kernel.xml.SAXReaderUtil;
039    import com.liferay.portal.util.PortalUtil;
040    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
041    import com.liferay.portlet.dynamicdatamapping.model.DDMTemplate;
042    import com.liferay.portlet.dynamicdatamapping.model.DDMTemplateConstants;
043    import com.liferay.portlet.dynamicdatamapping.storage.Fields;
044    import com.liferay.util.freemarker.FreeMarkerTaglibFactoryUtil;
045    
046    import freemarker.ext.servlet.HttpRequestHashModel;
047    import freemarker.ext.servlet.ServletContextHashModel;
048    
049    import freemarker.template.ObjectWrapper;
050    import freemarker.template.TemplateHashModel;
051    
052    import java.io.IOException;
053    import java.io.Writer;
054    
055    import java.util.HashMap;
056    import java.util.List;
057    import java.util.Locale;
058    import java.util.Map;
059    
060    import javax.servlet.GenericServlet;
061    import javax.servlet.Servlet;
062    import javax.servlet.ServletException;
063    import javax.servlet.ServletRequest;
064    import javax.servlet.ServletResponse;
065    import javax.servlet.http.HttpServletRequest;
066    import javax.servlet.http.HttpServletResponse;
067    import javax.servlet.jsp.PageContext;
068    
069    /**
070     * @author Bruno Basto
071     * @author Eduardo Lundgren
072     * @author Brian Wing Shun Chan
073     */
074    public class DDMXSDImpl implements DDMXSD {
075    
076            public String getHTML(
077                            PageContext pageContext, DDMStructure ddmStructure, Fields fields,
078                            String namespace, boolean readOnly, Locale locale)
079                    throws Exception {
080    
081                    return getHTML(
082                            pageContext, ddmStructure.getXsd(), fields, namespace, readOnly,
083                            locale);
084            }
085    
086            public String getHTML(
087                            PageContext pageContext, DDMTemplate ddmTemplate, Fields fields,
088                            String namespace, boolean readOnly, Locale locale)
089                    throws Exception {
090    
091                    return getHTML(
092                            pageContext, ddmTemplate.getScript(), fields, namespace,
093                            ddmTemplate.getMode(), readOnly, locale);
094            }
095    
096            public String getHTML(
097                            PageContext pageContext, Element element, Fields fields,
098                            Locale locale)
099                    throws Exception {
100    
101                    return getHTML(
102                            pageContext, element, fields, StringPool.BLANK, null, false,
103                            locale);
104            }
105    
106            public String getHTML(
107                            PageContext pageContext, Element element, Fields fields,
108                            String namespace, String mode, boolean readOnly, Locale locale)
109                    throws Exception {
110    
111                    StringBundler sb = new StringBundler();
112    
113                    HttpServletRequest request =
114                            (HttpServletRequest)pageContext.getRequest();
115    
116                    String portletId = PortalUtil.getPortletId(request);
117    
118                    String portletNamespace = PortalUtil.getPortletNamespace(portletId);
119    
120                    List<Element> dynamicElementElements = element.elements(
121                            "dynamic-element");
122    
123                    for (Element dynamicElementElement : dynamicElementElements) {
124                            FreeMarkerContext freeMarkerContext = getFreeMarkerContext(
125                                    dynamicElementElement, locale);
126    
127                            freeMarkerContext.put("portletNamespace", portletNamespace);
128                            freeMarkerContext.put("namespace", namespace);
129    
130                            if (fields != null) {
131                                    freeMarkerContext.put("fields", fields);
132                            }
133    
134                            Map<String, Object> field =
135                                    (Map<String, Object>)freeMarkerContext.get("fieldStructure");
136    
137                            String childrenHTML = getHTML(
138                                    pageContext, dynamicElementElement, fields, namespace, mode,
139                                    readOnly, locale);
140    
141                            field.put("children", childrenHTML);
142    
143                            String fieldNamespace = dynamicElementElement.attributeValue(
144                                    "fieldNamespace", _DEFAULT_NAMESPACE);
145    
146                            String defaultResourcePath = _TPL_DEFAULT_PATH;
147    
148                            boolean fieldReadOnly = GetterUtil.getBoolean(
149                                    field.get("readOnly"));
150    
151                            if ((fieldReadOnly && Validator.isNotNull(mode) &&
152                                     mode.equalsIgnoreCase(
153                                            DDMTemplateConstants.TEMPLATE_MODE_EDIT)) || readOnly) {
154    
155                                    fieldNamespace = _DEFAULT_READ_ONLY_NAMESPACE;
156    
157                                    defaultResourcePath = _TPL_DEFAULT_READ_ONLY_PATH;
158                            }
159    
160                            String type = dynamicElementElement.attributeValue("type");
161    
162                            String templateName = StringUtil.replaceFirst(
163                                    type, fieldNamespace.concat(StringPool.DASH), StringPool.BLANK);
164    
165                            StringBundler resourcePath = new StringBundler(5);
166    
167                            resourcePath.append(_TPL_PATH);
168                            resourcePath.append(fieldNamespace.toLowerCase());
169                            resourcePath.append(CharPool.SLASH);
170                            resourcePath.append(templateName);
171                            resourcePath.append(_TPL_EXT);
172    
173                            sb.append(
174                                    processFTL(
175                                            pageContext, freeMarkerContext, resourcePath.toString(),
176                                            defaultResourcePath));
177                    }
178    
179                    return sb.toString();
180            }
181    
182            public String getHTML(
183                            PageContext pageContext, Element element, Locale locale)
184                    throws Exception {
185    
186                    return getHTML(pageContext, element, null, locale);
187            }
188    
189            public String getHTML(
190                            PageContext pageContext, String xml, Fields fields, Locale locale)
191                    throws Exception {
192    
193                    return getHTML(pageContext, xml, fields, StringPool.BLANK, locale);
194            }
195    
196            public String getHTML(
197                            PageContext pageContext, String xml, Fields fields,
198                            String namespace, boolean readOnly, Locale locale)
199                    throws Exception {
200    
201                    return getHTML(
202                            pageContext, xml, fields, namespace, null, readOnly, locale);
203            }
204    
205            public String getHTML(
206                            PageContext pageContext, String xml, Fields fields,
207                            String namespace, Locale locale)
208                    throws Exception {
209    
210                    return getHTML(pageContext, xml, fields, namespace, false, locale);
211            }
212    
213            public String getHTML(
214                            PageContext pageContext, String xml, Fields fields,
215                            String namespace, String mode, boolean readOnly, Locale locale)
216                    throws Exception {
217    
218                    Document document = SAXReaderUtil.read(xml);
219    
220                    return getHTML(
221                            pageContext, document.getRootElement(), fields, namespace, mode,
222                            readOnly, locale);
223            }
224    
225            public String getHTML(PageContext pageContext, String xml, Locale locale)
226                    throws Exception {
227    
228                    return getHTML(pageContext, xml, null, locale);
229            }
230    
231            public JSONArray getJSONArray(Document document) throws JSONException {
232                    return getJSONArray(document.getRootElement());
233            }
234    
235            public JSONArray getJSONArray(Element element) throws JSONException {
236                    JSONArray jsonArray = JSONFactoryUtil.createJSONArray();
237    
238                    Document document = element.getDocument();
239    
240                    String defaultLocale = LocalizationUtil.getDefaultLocale(
241                            document.asXML());
242    
243                    List<Element> dynamicElementElements = element.elements(
244                            "dynamic-element");
245    
246                    for (Element dynamicElementElement : dynamicElementElements) {
247                            JSONObject jsonObject = JSONFactoryUtil.createJSONObject();
248                            JSONObject localizationMapJSONObject =
249                                    JSONFactoryUtil.createJSONObject();
250    
251                            List<Element> metadataElements = dynamicElementElement.elements(
252                                    "meta-data");
253    
254                            for (Element metadataElement : metadataElements) {
255                                    if (metadataElement == null) {
256                                            continue;
257                                    }
258    
259                                    String locale = metadataElement.attributeValue("locale");
260    
261                                    JSONObject localeMap = JSONFactoryUtil.createJSONObject();
262    
263                                    localizationMapJSONObject.put(locale, localeMap);
264    
265                                    for (Element metadataEntryElement :
266                                                    metadataElement.elements()) {
267    
268                                            String attributeName = metadataEntryElement.attributeValue(
269                                                    "name");
270                                            String attributeValue = metadataEntryElement.getText();
271    
272                                            localeMap.put(attributeName, attributeValue);
273    
274                                            if (defaultLocale.equals(locale)) {
275                                                    jsonObject.put(attributeName, attributeValue);
276                                            }
277                                    }
278                            }
279    
280                            jsonObject.put("localizationMap", localizationMapJSONObject);
281    
282                            for (Attribute attribute : dynamicElementElement.attributes()) {
283                                    jsonObject.put(attribute.getName(), attribute.getValue());
284                            }
285    
286                            jsonObject.put("id", dynamicElementElement.attributeValue("name"));
287    
288                            JSONArray hiddenAttributesJSONArray =
289                                    JSONFactoryUtil.createJSONArray();
290    
291                            String type = jsonObject.getString("type");
292    
293                            if (type.equals(_TYPE_CHECKBOX)) {
294                                    hiddenAttributesJSONArray.put("required");
295                            }
296    
297                            if (type.equals(_TYPE_DDM_FILEUPLOAD)) {
298                                    hiddenAttributesJSONArray.put("predefinedValue");
299                            }
300    
301                            hiddenAttributesJSONArray.put("readOnly");
302    
303                            jsonObject.put("hiddenAttributes", hiddenAttributesJSONArray);
304    
305                            String key = "fields";
306    
307                            if (type.equals(_TYPE_RADIO) || type.equals(_TYPE_SELECT)) {
308                                    key = "options";
309    
310                                    String predefinedValue = jsonObject.getString(
311                                            "predefinedValue");
312    
313                                    jsonObject.put(
314                                            "predefinedValue",
315                                            JSONFactoryUtil.createJSONArray(predefinedValue));
316                            }
317    
318                            jsonObject.put(key, getJSONArray(dynamicElementElement));
319    
320                            jsonArray.put(jsonObject);
321                    }
322    
323                    return jsonArray;
324            }
325    
326            public JSONArray getJSONArray(String xml)
327                    throws DocumentException, JSONException {
328    
329                    return getJSONArray(SAXReaderUtil.read(xml));
330            }
331    
332            protected Map<String, Object> getFieldContext(
333                    Element dynamicElementElement, Locale locale) {
334    
335                    Document document = dynamicElementElement.getDocument();
336    
337                    String[] availableLocales = LocalizationUtil.getAvailableLocales(
338                            document.asXML());
339    
340                    String defaultLanguageId = LocalizationUtil.getDefaultLocale(
341                            document.asXML());
342    
343                    String languageId = LocaleUtil.toLanguageId(locale);
344    
345                    if (!ArrayUtil.contains(availableLocales, languageId)) {
346                            languageId = defaultLanguageId;
347                    }
348    
349                    Element metadataElement =
350                            (Element)dynamicElementElement.selectSingleNode(
351                                    "meta-data[@locale='" + languageId + "']");
352    
353                    Map<String, Object> field = new HashMap<String, Object>();
354    
355                    if (metadataElement != null) {
356                            for (Element metadataEntry : metadataElement.elements()) {
357                                    field.put(
358                                            metadataEntry.attributeValue("name"),
359                                            metadataEntry.getText());
360                            }
361                    }
362    
363                    for (Attribute attribute : dynamicElementElement.attributes()) {
364                            field.put(attribute.getName(), attribute.getValue());
365                    }
366    
367                    return field;
368            }
369    
370            protected FreeMarkerContext getFreeMarkerContext(
371                    Element dynamicElementElement, Locale locale) {
372    
373                    FreeMarkerContext freeMarkerContext =
374                            FreeMarkerEngineUtil.getWrappedStandardToolsContext();
375    
376                    Map<String, Object> fieldContext = getFieldContext(
377                            dynamicElementElement, locale);
378    
379                    Map<String, Object> parentFieldContext = new HashMap<String, Object>();
380    
381                    Element parentElement = dynamicElementElement.getParent();
382    
383                    if (parentElement != null) {
384                            parentFieldContext = getFieldContext(parentElement, locale);
385                    }
386    
387                    freeMarkerContext.put("fieldStructure", fieldContext);
388                    freeMarkerContext.put("parentFieldStructure", parentFieldContext);
389    
390                    return freeMarkerContext;
391            }
392    
393            /**
394             * @see com.liferay.taglib.util.ThemeUtil#includeFTL
395             */
396            protected String processFTL(
397                            PageContext pageContext, FreeMarkerContext freeMarkerContext,
398                            String resourcePath, String defaultResourcePath)
399                    throws Exception {
400    
401                    if (!FreeMarkerEngineUtil.resourceExists(resourcePath)) {
402                            resourcePath = defaultResourcePath;
403                    }
404    
405                    HttpServletRequest request =
406                            (HttpServletRequest)pageContext.getRequest();
407    
408                    // FreeMarker variables
409    
410                    FreeMarkerVariablesUtil.insertVariables(freeMarkerContext, request);
411    
412                    // Tag libraries
413    
414                    HttpServletResponse response =
415                            (HttpServletResponse)pageContext.getResponse();
416    
417                    Writer writer = new UnsyncStringWriter();
418    
419                    // Portal JSP tag library factory
420    
421                    TemplateHashModel portalTaglib =
422                            FreeMarkerTaglibFactoryUtil.createTaglibFactory(
423                                    pageContext.getServletContext());
424    
425                    freeMarkerContext.put("PortalJspTagLibs", portalTaglib);
426    
427                    // FreeMarker JSP tag library support
428    
429                    final Servlet servlet = (Servlet)pageContext.getPage();
430    
431                    GenericServlet genericServlet = null;
432    
433                    if (servlet instanceof GenericServlet) {
434                            genericServlet = (GenericServlet)servlet;
435                    }
436                    else {
437                            genericServlet = new GenericServlet() {
438    
439                                    @Override
440                                    public void service(
441                                                    ServletRequest servletRequest,
442                                                    ServletResponse servletResponse)
443                                            throws ServletException, IOException {
444    
445                                            servlet.service(servletRequest, servletResponse);
446                                    }
447    
448                            };
449    
450                            genericServlet.init(pageContext.getServletConfig());
451                    }
452    
453                    ServletContextHashModel servletContextHashModel =
454                            new ServletContextHashModel(
455                                    genericServlet, ObjectWrapper.DEFAULT_WRAPPER);
456    
457                    freeMarkerContext.put("Application", servletContextHashModel);
458    
459                    HttpRequestHashModel httpRequestHashModel = new HttpRequestHashModel(
460                            request, response, ObjectWrapper.DEFAULT_WRAPPER);
461    
462                    freeMarkerContext.put("Request", httpRequestHashModel);
463    
464                    // Merge templates
465    
466                    FreeMarkerEngineUtil.mergeTemplate(
467                            resourcePath, freeMarkerContext, writer);
468    
469                    return writer.toString();
470            }
471    
472            private static final String _DEFAULT_NAMESPACE = "alloy";
473    
474            private static final String _DEFAULT_READ_ONLY_NAMESPACE = "readonly";
475    
476            private static final String _TPL_DEFAULT_PATH =
477                    "com/liferay/portlet/dynamicdatamapping/dependencies/alloy/text.ftl";
478    
479            private static final String _TPL_DEFAULT_READ_ONLY_PATH =
480                    "com/liferay/portlet/dynamicdatamapping/dependencies/readonly/" +
481                            "default.ftl";
482    
483            private static final String _TPL_EXT = ".ftl";
484    
485            private static final String _TPL_PATH =
486                    "com/liferay/portlet/dynamicdatamapping/dependencies/";
487    
488            private static final String _TYPE_CHECKBOX = "checkbox";
489    
490            private static final String _TYPE_DDM_FILEUPLOAD = "ddm-fileupload";
491    
492            private static final String _TYPE_RADIO = "radio";
493    
494            private static final String _TYPE_SELECT = "select";
495    
496    }