mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-07 17:49:17 +00:00
cabab31ec0
fixing columns in create form wizard to not move around wildy once files are uploaded
fixing some bugs in repeats as a result of the chiba1.3 upgrade.
- xpaths were not being resolved for newly created instances (and shouldn't be)
- xpaths for nested repeats weren't behaving properly
fixed caching issue in edit which was causing the wrong form to be loaded for instance data
using alfresco namespace as defined in NamespaceService
passing namespace uris and prefixes to js to avoid errors if they should change
fixed a bug where the renditions property of forminstancedata was getting duplicate renditions (and thus regenerating way too much stuff when doing an edit)
using an italic 'description not set' when description isn't set in several screens.
using the avm service to set properties in renderingenginetemplateimpl.
upgrading to xalan-2.7.0 in order to be able to use bsf for extension functions.
adding the path that was not found to AVMNotFoundExceptions. very helpful when debugging.
substantial refactoring of rendering engines in preparation for integration with TemplateService.
- implementing a common model as a hash of QNames to objects. for method, providing a simple method wrapper called TemplateProcessorMethod which takes an array of Objects as a parameter, and returns an object. it is up to the template processors to properly convert arguments. a QName is used for the variable name rather than a string in order to include a namespace prefix (needed for xsl, and generally better looking).
- for xsl, using javascript bindings for formdatafunctions, which using liveconnect within rhino to call into the xsl rendering engine to evaluate the function. it ends up generating this js block into a xalan:component within the xsl tempalte:
// gets the handle to the backing java object which can invoke the function based on id
var _xsltp_invoke = java.lang.Class.forName('org.alfresco.web.forms.XSLTRenderingEngine$ProcessorMethodInvoker').newInstance();
// utility to convert js arrays into java
function _xsltp_to_java_array(js_array) {
var java_array = java.lang.reflect.Array.newInstance(java.lang.Object, js_array.length);
for (var i = 0; i < js_array.length; i++) { java_array[i] = js_array[i]; }
return java_array; }
// js handles to each of the form data functions which uses _xsltp_invoke to call the actual method
function _getAVMPath() { return _xsltp_invoke.invokeMethod('_getAVMPath8829055', _xsltp_to_java_array(arguments)); }
function parseXMLDocuments() { return _xsltp_invoke.invokeMethod('parseXMLDocuments12235190', _xsltp_to_java_array(arguments)); }
function parseXMLDocument() { return _xsltp_invoke.invokeMethod('parseXMLDocument15280968', _xsltp_to_java_array(arguments)); }
xml model data is inferred as a root namespace document within the model hash provided.
- for freemarker, things pretty much work as they did before, just i now need to convert values by hand to TemplateModels
fixed a bug with hidden iframe upload. seems like the complexity of actually cloning the file input element is unnecessary and that simply attaching the node in two places within the dom works just fine.
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@4764 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
459 lines
17 KiB
Java
459 lines
17 KiB
Java
/*
|
|
* Copyright (C) 2005 Alfresco, Inc.
|
|
*
|
|
* Licensed under the Mozilla Public License version 1.1
|
|
* with a permitted attribution clause. You may obtain a
|
|
* copy of the License at
|
|
*
|
|
* http://www.alfresco.org/legal/license.txt
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
|
* either express or implied. See the License for the specific
|
|
* language governing permissions and limitations under the
|
|
* License.
|
|
*/
|
|
package org.alfresco.web.forms;
|
|
|
|
import java.io.*;
|
|
import java.net.URI;
|
|
import java.net.URISyntaxException;
|
|
import java.util.*;
|
|
import javax.xml.parsers.DocumentBuilder;
|
|
import javax.xml.transform.Result;
|
|
import javax.xml.transform.Source;
|
|
import javax.xml.transform.Transformer;
|
|
import javax.xml.transform.TransformerConfigurationException;
|
|
import javax.xml.transform.TransformerException;
|
|
import javax.xml.transform.TransformerFactory;
|
|
import javax.xml.transform.URIResolver;
|
|
import javax.xml.transform.dom.DOMSource;
|
|
import javax.xml.transform.sax.TransformerHandler;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
import javax.xml.transform.stream.StreamSource;
|
|
import org.alfresco.service.cmr.repository.ContentService;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.web.bean.wcm.AVMConstants;
|
|
import org.alfresco.web.forms.XMLUtil;
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
import org.apache.xalan.extensions.ExpressionContext;
|
|
import org.apache.xpath.objects.XObject;
|
|
import org.apache.xml.dtm.ref.DTMNodeProxy;
|
|
import org.apache.xml.utils.Constants;
|
|
//import org.apache.xml.utils.QName;
|
|
import org.w3c.dom.*;
|
|
import org.w3c.dom.traversal.NodeFilter;
|
|
import org.w3c.dom.traversal.NodeIterator;
|
|
import org.xml.sax.SAXException;
|
|
import org.apache.bsf.BSFManager;
|
|
|
|
/**
|
|
* A rendering engine which uses xsl templates to render renditions of
|
|
* form instance data.
|
|
*
|
|
* @author Ariel Backenroth
|
|
*/
|
|
public class XSLTRenderingEngine
|
|
implements RenderingEngine
|
|
{
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
public static class ProcessorMethodInvoker
|
|
{
|
|
private final static HashMap<String, TemplateProcessorMethod> PROCESSOR_METHODS =
|
|
new HashMap<String, TemplateProcessorMethod>();
|
|
|
|
public ProcessorMethodInvoker() { }
|
|
|
|
private Object[] convertArguments(final Object[] arguments)
|
|
{
|
|
final List result = new LinkedList();
|
|
for (int i = 0; i < arguments.length; i++)
|
|
{
|
|
LOGGER.debug("args[" + i + "] = " + arguments[i] +
|
|
"(" + (arguments[i] != null
|
|
? arguments[i].getClass().getName()
|
|
: "null") + ")");
|
|
if (arguments[i] == null ||
|
|
arguments[i] instanceof String ||
|
|
arguments[i] instanceof Number)
|
|
{
|
|
result.add(arguments[i]);
|
|
}
|
|
else if (arguments[i] instanceof DTMNodeProxy)
|
|
{
|
|
result.add(((DTMNodeProxy)arguments[i]).getStringValue());
|
|
}
|
|
else if (arguments[i] instanceof Node)
|
|
{
|
|
LOGGER.debug("node type is " + ((Node)arguments[i]).getNodeType() +
|
|
" content " + ((Node)arguments[i]).getTextContent());
|
|
result.add(((Node)arguments[i]).getNodeValue());
|
|
}
|
|
else if (arguments[i] instanceof NodeIterator)
|
|
{
|
|
Node n = ((NodeIterator)arguments[i]).nextNode();
|
|
while (n != null)
|
|
{
|
|
LOGGER.debug("iterated to node " + n + " type " + n.getNodeType() +
|
|
" value " + n.getNodeValue() +
|
|
" tc " + n.getTextContent() +
|
|
" nn " + n.getNodeName() +
|
|
" sv " + ((org.apache.xml.dtm.ref.DTMNodeProxy)n).getStringValue());
|
|
if (n instanceof DTMNodeProxy)
|
|
{
|
|
result.add(((DTMNodeProxy)n).getStringValue());
|
|
}
|
|
else
|
|
{
|
|
result.add(n);
|
|
}
|
|
n = ((NodeIterator)arguments[i]).nextNode();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new IllegalArgumentException("unable to convert argument " + arguments[i]);
|
|
}
|
|
}
|
|
|
|
return result.toArray(new Object[result.size()]);
|
|
}
|
|
|
|
public Object invokeMethod(final String id, Object[] arguments)
|
|
throws Exception
|
|
{
|
|
if (!PROCESSOR_METHODS.containsKey(id))
|
|
{
|
|
throw new NullPointerException("unable to find method " + id);
|
|
}
|
|
|
|
final TemplateProcessorMethod method = PROCESSOR_METHODS.get(id);
|
|
arguments = this.convertArguments(arguments);
|
|
LOGGER.debug("invoking " + id + " with " + arguments.length);
|
|
|
|
Object result = method.exec(arguments);
|
|
LOGGER.debug(id + " returned a " + result);
|
|
if (result == null)
|
|
{
|
|
return null;
|
|
}
|
|
else if (result.getClass().isArray() &&
|
|
Node.class.isAssignableFrom(result.getClass().getComponentType()))
|
|
{
|
|
LOGGER.debug("converting " + result + " to a node iterator");
|
|
final Node[] array = (Node[])result;
|
|
return new NodeIterator()
|
|
{
|
|
private int index = 0;
|
|
private boolean detached = false;
|
|
|
|
public void detach()
|
|
{
|
|
if (LOGGER.isDebugEnabled())
|
|
LOGGER.debug("detaching NodeIterator");
|
|
this.detached = true;
|
|
}
|
|
|
|
public boolean getExpandEntityReferences() { return true; }
|
|
public int getWhatToShow() { return NodeFilter.SHOW_ALL; }
|
|
|
|
public Node getRoot()
|
|
{
|
|
return (array.length == 0
|
|
? null
|
|
: array[0].getOwnerDocument().getDocumentElement());
|
|
}
|
|
|
|
public NodeFilter getFilter()
|
|
{
|
|
return new NodeFilter()
|
|
{
|
|
public short acceptNode(final Node n)
|
|
{
|
|
return NodeFilter.FILTER_ACCEPT;
|
|
}
|
|
};
|
|
}
|
|
|
|
public Node nextNode()
|
|
throws DOMException
|
|
{
|
|
if (LOGGER.isDebugEnabled())
|
|
LOGGER.debug("NodeIterator.nextNode(" + index + ")");
|
|
if (this.detached)
|
|
throw new DOMException(DOMException.INVALID_STATE_ERR, null);
|
|
return index == array.length ? null : array[index++];
|
|
}
|
|
|
|
public Node previousNode()
|
|
throws DOMException
|
|
{
|
|
if (LOGGER.isDebugEnabled())
|
|
LOGGER.debug("NodeIterator.previousNode(" + index + ")");
|
|
if (this.detached)
|
|
throw new DOMException(DOMException.INVALID_STATE_ERR, null);
|
|
return index == -1 ? null : array[index--];
|
|
}
|
|
};
|
|
}
|
|
else if (result instanceof String ||
|
|
result instanceof Number ||
|
|
result instanceof Node)
|
|
{
|
|
LOGGER.debug("returning " + result + " as is");
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
throw new IllegalArgumentException("unable to convert " + result.getClass().getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
private static final Log LOGGER = LogFactory.getLog(XSLTRenderingEngine.class);
|
|
|
|
public static final QName PROP_URI_RESOLVER_BASE_URI =
|
|
QName.createQName(NamespaceService.ALFRESCO_URI, "xslt_resolver_base_uri");
|
|
|
|
public XSLTRenderingEngine() { }
|
|
|
|
public String getName() { return "XSLT"; }
|
|
|
|
public String getDefaultTemplateFileExtension() { return "xsl"; }
|
|
|
|
/**
|
|
* Adds a script element to the xsl which makes static methods on this
|
|
* object available to the xsl tempalte.
|
|
*
|
|
* @param xslTemplate the xsl template
|
|
*/
|
|
protected List<String> addScripts(final Map<QName, Object> model,
|
|
final Document xslTemplate)
|
|
{
|
|
final Map<QName, List<Map.Entry<QName, Object>>> methods =
|
|
new HashMap<QName, List<Map.Entry<QName, Object>>>();
|
|
for (final Map.Entry<QName, Object> entry : model.entrySet())
|
|
{
|
|
if (entry.getValue() instanceof TemplateProcessorMethod)
|
|
{
|
|
final String prefix = QName.splitPrefixedQName(entry.getKey().toPrefixString())[0];
|
|
final QName qn = QName.createQName(entry.getKey().getNamespaceURI(),
|
|
prefix);
|
|
if (!methods.containsKey(qn))
|
|
{
|
|
methods.put(qn, new LinkedList());
|
|
}
|
|
methods.get(qn).add(entry);
|
|
}
|
|
}
|
|
|
|
final Element docEl = xslTemplate.getDocumentElement();
|
|
final String XALAN_NS = Constants.S_BUILTIN_EXTENSIONS_URL;
|
|
final String XALAN_NS_PREFIX = "xalan";
|
|
docEl.setAttribute("xmlns:" + XALAN_NS_PREFIX, XALAN_NS);
|
|
|
|
final List<String> result = new LinkedList<String>();
|
|
for (QName ns : methods.keySet())
|
|
{
|
|
final String prefix = ns.getLocalName();
|
|
docEl.setAttribute("xmlns:" + prefix, ns.getNamespaceURI());
|
|
|
|
final Element compEl = xslTemplate.createElementNS(XALAN_NS,
|
|
XALAN_NS_PREFIX + ":component");
|
|
compEl.setAttribute("prefix", prefix);
|
|
docEl.appendChild(compEl);
|
|
String functionNames = null;
|
|
final Element scriptEl = xslTemplate.createElementNS(XALAN_NS,
|
|
XALAN_NS_PREFIX + ":script");
|
|
scriptEl.setAttribute("lang", "javascript");
|
|
final StringBuilder js =
|
|
new StringBuilder("var _xsltp_invoke = java.lang.Class.forName('" + ProcessorMethodInvoker.class.getName() +
|
|
"').newInstance();\n" +
|
|
"function _xsltp_to_java_array(js_array) {\n" +
|
|
"var java_array = java.lang.reflect.Array.newInstance(java.lang.Object, js_array.length);\n" +
|
|
"for (var i = 0; i < js_array.length; i++) { java_array[i] = js_array[i]; }\n" +
|
|
"return java_array; }\n");
|
|
for (final Map.Entry<QName, Object> entry : methods.get(ns))
|
|
{
|
|
if (functionNames == null)
|
|
{
|
|
functionNames = entry.getKey().getLocalName();
|
|
}
|
|
else
|
|
{
|
|
functionNames += " " + entry.getKey().getLocalName();
|
|
}
|
|
final String id = entry.getKey().getLocalName() + entry.getValue().hashCode();
|
|
js.append("function " + entry.getKey().getLocalName() +
|
|
"() { return _xsltp_invoke.invokeMethod('" + id +
|
|
"', _xsltp_to_java_array(arguments)); }\n");
|
|
ProcessorMethodInvoker.PROCESSOR_METHODS.put(id, (TemplateProcessorMethod)entry.getValue());
|
|
result.add(id);
|
|
}
|
|
LOGGER.debug("generated JavaScript bindings:\n" + js);
|
|
scriptEl.appendChild(xslTemplate.createTextNode(js.toString()));
|
|
compEl.setAttribute("functions", functionNames);
|
|
compEl.appendChild(scriptEl);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Adds the specified parameters to the xsl template as variables within the
|
|
* alfresco namespace.
|
|
*
|
|
* @param parameters the variables to place within the xsl template
|
|
* @param xslTemplate the xsl template
|
|
*/
|
|
protected void addParameters(final Map<QName, Object> model,
|
|
final Document xslTemplate)
|
|
{
|
|
final Element docEl = xslTemplate.getDocumentElement();
|
|
final String XSL_NS = docEl.getNamespaceURI();
|
|
final String XSL_NS_PREFIX = docEl.getPrefix();
|
|
|
|
for (Map.Entry<QName, Object> e : model.entrySet())
|
|
{
|
|
if (RenderingEngine.ROOT_NAMESPACE.equals(e.getKey()))
|
|
{
|
|
continue;
|
|
}
|
|
final Element el = xslTemplate.createElementNS(XSL_NS, XSL_NS_PREFIX + ":variable");
|
|
el.setAttribute("name", e.getKey().toPrefixString());
|
|
final Object o = e.getValue();
|
|
if (o instanceof String || o instanceof Number || o instanceof Boolean)
|
|
{
|
|
el.appendChild(xslTemplate.createTextNode(o.toString()));
|
|
docEl.insertBefore(el, docEl.getFirstChild());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected Source getXMLSource(final Map<QName, Object> model)
|
|
{
|
|
if (!model.containsKey(RenderingEngine.ROOT_NAMESPACE))
|
|
{
|
|
return null;
|
|
}
|
|
final Object o = model.get(RenderingEngine.ROOT_NAMESPACE);
|
|
if (!(o instanceof Document))
|
|
{
|
|
throw new IllegalArgumentException("expected root namespace object to be a " + Document.class.getName() +
|
|
". found a " + o.getClass().getName());
|
|
}
|
|
return new DOMSource((Document)o);
|
|
}
|
|
|
|
public void render(final Map<QName, Object> model,
|
|
final RenderingEngineTemplate ret,
|
|
final OutputStream out)
|
|
throws IOException,
|
|
RenderingEngine.RenderingException,
|
|
SAXException
|
|
{
|
|
this.render(model, ret, new StreamResult(out));
|
|
}
|
|
|
|
public void render(final Map<QName, Object> model,
|
|
final RenderingEngineTemplate ret,
|
|
final Result result)
|
|
throws IOException,
|
|
RenderingEngine.RenderingException,
|
|
SAXException
|
|
{
|
|
System.setProperty("org.apache.xalan.extensions.bsf.BSFManager",
|
|
BSFManager.class.getName());
|
|
Document xslTemplate = null;
|
|
try
|
|
{
|
|
xslTemplate = XMLUtil.parse(ret.getInputStream());
|
|
}
|
|
catch (final SAXException sax)
|
|
{
|
|
throw new RenderingEngine.RenderingException(sax);
|
|
}
|
|
this.addScripts(model, xslTemplate);
|
|
this.addParameters(model, xslTemplate);
|
|
|
|
Source xmlSource = this.getXMLSource(model);
|
|
|
|
Transformer t = null;
|
|
try
|
|
{
|
|
final TransformerFactory tf = TransformerFactory.newInstance();
|
|
t = tf.newTransformer(new DOMSource(xslTemplate));
|
|
t.setParameter("versionParam", "2.0");
|
|
}
|
|
catch (TransformerConfigurationException tce)
|
|
{
|
|
LOGGER.error(tce);
|
|
throw new RenderingEngine.RenderingException(tce);
|
|
}
|
|
|
|
// create a uri resolver to resolve document() calls to the virtualized
|
|
// web application
|
|
t.setURIResolver(new URIResolver()
|
|
{
|
|
public Source resolve(final String href, String base)
|
|
throws TransformerException
|
|
{
|
|
LOGGER.debug("request to resolve href " + href +
|
|
" using base " + base);
|
|
if (model.containsKey(PROP_URI_RESOLVER_BASE_URI))
|
|
{
|
|
base = (String)model.get(PROP_URI_RESOLVER_BASE_URI);
|
|
LOGGER.debug("overriding base with " + base);
|
|
}
|
|
|
|
URI uri = null;
|
|
try
|
|
{
|
|
uri = new URI(base + href);
|
|
}
|
|
catch (URISyntaxException e)
|
|
{
|
|
throw new TransformerException("unable to create uri " + base + href,
|
|
e);
|
|
}
|
|
try
|
|
{
|
|
if (LOGGER.isDebugEnabled())
|
|
LOGGER.debug("loading " + uri);
|
|
final Document d = XMLUtil.parse(uri.toURL().openStream());
|
|
if (LOGGER.isDebugEnabled())
|
|
LOGGER.debug("loaded " + XMLUtil.toString(d));
|
|
return new DOMSource(d);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new TransformerException("unable to load " + uri, e);
|
|
}
|
|
}
|
|
});
|
|
|
|
try
|
|
{
|
|
t.transform(xmlSource, result);
|
|
}
|
|
catch (TransformerException te)
|
|
{
|
|
LOGGER.error(te.getMessageAndLocation());
|
|
throw new RenderingEngine.RenderingException(te);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LOGGER.error("unexpected error " + e);
|
|
throw new RenderingEngine.RenderingException(e);
|
|
}
|
|
}
|
|
}
|