runtime/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedXmlConverterCompat.java

   1 package org.argeo.slc.detached;
   2
   3 import java.io.StringReader;
   4 import java.util.Enumeration;
   5 import java.util.Properties;
   6
   7 import javax.xml.transform.Result;
   8 import javax.xml.transform.Source;
   9 import javax.xml.transform.Transformer;
  10 import javax.xml.transform.TransformerException;
  11 import javax.xml.transform.TransformerFactory;
  12 import javax.xml.transform.dom.DOMResult;
  13 import javax.xml.transform.stream.StreamSource;
  14
  15 import org.apache.commons.io.IOUtils;
  16 import org.w3c.dom.Document;
  17 import org.w3c.dom.Element;
  18 import org.w3c.dom.NodeList;
  19
  20 /** For compatibility with old JDKs (pre 1.5). Use Spring base one when possible. */
  21 public class DetachedXmlConverterCompat implements DetachedXmlConverter {
  22         public final static String SLC_DETACHED_NAMESPACE_URI = "http://argeo.org/projects/slc/schemas/detached";
  23         // private final static Log log = LogFactory
  24         // .getLog(DetachedXmlConverterCompat.class);
  25
  26         private final Transformer copy;
  27
  28         public DetachedXmlConverterCompat() {
  29                 try {
  30                         copy = TransformerFactory.newInstance().newTransformer();
  31                 } catch (Exception e) {
  32                         throw new DetachedException("Could not create transformer.", e);
  33                 }
  34         }
  35
  36         public void marshallCommunication(DetachedCommunication detCom,
  37                         Result result) {
  38                 if (detCom instanceof DetachedRequest) {
  39                         marshallRequest((DetachedRequest) detCom, result);
  40                 } else if (detCom instanceof DetachedAnswer) {
  41                         marshallAnswer((DetachedAnswer) detCom, result);
  42                 } else {
  43                         throw new DetachedException("Unkown communication type "
  44                                         + detCom.getClass());
  45                 }
  46         }
  47
  48         public DetachedCommunication unmarshallCommunication(Source source) {
  49                 // Parse
  50                 DOMResult result = new DOMResult();
  51                 try {
  52                         copy.transform(source, result);
  53                 } catch (TransformerException e) {
  54                         throw new DetachedException("Could not copy xml source", e);
  55                 }
  56                 Element root = (Element) ((Document) result.getNode())
  57                                 .getDocumentElement();
  58
  59                 // Create objects
  60                 String requestType = root.getLocalName();
  61                 if (requestType.equals("detached-request")) {
  62                         DetachedRequest request = new DetachedRequest();
  63                         request.setUuid(root.getElementsByTagNameNS(
  64                                         SLC_DETACHED_NAMESPACE_URI, "uuid").item(0)
  65                                         .getTextContent());
  66                         request
  67                                         .setRef(root.getElementsByTagNameNS(
  68                                                         SLC_DETACHED_NAMESPACE_URI, "ref").item(0)
  69                                                         .getTextContent());
  70                         request.setPath(root.getElementsByTagNameNS(
  71                                         SLC_DETACHED_NAMESPACE_URI, "path").item(0)
  72                                         .getTextContent());
  73                         Element propertiesElement = (Element) root.getElementsByTagNameNS(
  74                                         SLC_DETACHED_NAMESPACE_URI, "properties").item(0);
  75                         NodeList propElements = propertiesElement.getElementsByTagNameNS(
  76                                         SLC_DETACHED_NAMESPACE_URI, "prop");
  77                         Properties properties = new Properties();
  78                         for (int i = 0; i < propElements.getLength(); i++) {
  79                                 Element propElement = (Element) propElements.item(i);
  80                                 String key = propElement.getAttribute("key");
  81                                 String value = propElement.getTextContent();
  82                                 properties.setProperty(key, value);
  83                         }
  84                         request.setProperties(properties);
  85                         return request;
  86                 } else {
  87                         throw new DetachedException(requestType + " not implemented.");
  88                 }
  89         }
  90
  91         public void marshallAnswer(DetachedAnswer answer, Result result) {
  92                 StringBuffer buf = new StringBuffer("");
  93                 buf.append("<slc-det:detached-answer xmlns:slc-det=\""
  94                                 + SLC_DETACHED_NAMESPACE_URI + "\">");
  95                 if (answer.getUuid() != null)
  96                         buf.append("<slc-det:uuid>").append(answer.getUuid()).append(
  97                                         "</slc-det:uuid>");
  98                 buf.append("<slc-det:status>").append(answer.getStatus()).append(
  99                                 "</slc-det:status>");
 100                 if (answer.getLog() != null)
 101                         buf.append("<slc-det:log>").append(answer.getLog()).append(
 102                                         "</slc-det:log>");
 103                 if (answer.getProperties().size() != 0) {
 104                         buf.append("<slc-det:properties>");
 105                         Enumeration keys = answer.getProperties().keys();
 106                         while (keys.hasMoreElements()) {
 107                                 String key = (String) keys.nextElement();
 108                                 buf.append("<slc-det:prop key=\"").append(key).append("\">");
 109                                 buf.append(answer.getProperties().getProperty(key));
 110                                 buf.append("</slc-det:prop>");
 111                         }
 112                         buf.append("</slc-det:properties>");
 113                 }
 114                 buf.append("</slc-det:detached-answer>");
 115                 StringReader reader = new StringReader(buf.toString());
 116                 Source source = new StreamSource(reader);
 117                 try {
 118                         copy.transform(source, result);
 119                 } catch (TransformerException e) {
 120                         throw new DetachedException("Could not copy xml to result", e);
 121                 } finally {
 122                         IOUtils.closeQuietly(reader);
 123                 }
 124         }
 125
 126         public void marshallRequest(DetachedRequest request, Result result) {
 127                 throw new DetachedException(" Not implemented.");
 128         }
 129
 130         public DetachedRequest unmarshallRequest(Source source) {
 131                 DOMResult result = new DOMResult();
 132                 try {
 133                         copy.transform(source, result);
 134                 } catch (TransformerException e) {
 135                         throw new DetachedException("Could not copy xml source", e);
 136                 }
 137                 Element node = (Element) ((Document) result.getNode())
 138                                 .getDocumentElement();
 139                 DetachedRequest request = new DetachedRequest();
 140                 request.setUuid(node.getElementsByTagNameNS(SLC_DETACHED_NAMESPACE_URI,
 141                                 "uuid").item(0).getTextContent());
 142                 request.setRef(node.getElementsByTagNameNS(SLC_DETACHED_NAMESPACE_URI,
 143                                 "ref").item(0).getTextContent());
 144                 request.setPath(node.getElementsByTagNameNS(SLC_DETACHED_NAMESPACE_URI,
 145                                 "path").item(0).getTextContent());
 146                 Element propertiesElement = (Element) node.getElementsByTagNameNS(
 147                                 SLC_DETACHED_NAMESPACE_URI, "properties").item(0);
 148                 NodeList propElements = propertiesElement.getElementsByTagNameNS(
 149                                 SLC_DETACHED_NAMESPACE_URI, "prop");
 150                 Properties properties = new Properties();
 151                 for (int i = 0; i < propElements.getLength(); i++) {
 152                         Element propElement = (Element) propElements.item(i);
 153                         String key = propElement.getAttribute("key");
 154                         String value = propElement.getTextContent();
 155                         properties.setProperty(key, value);
 156                 }
 157                 request.setProperties(properties);
 158                 return request;
 159         }
 160 }