1 files changed, 132 insertions, 34 deletions

diff --git a/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SLResultImpl.java b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SLResultImpl.java
index a79382b6..57309182 100644
--- a/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SLResultImpl.java
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SLResultImpl.java
@@ -16,24 +16,33 @@
 */
 package at.gv.egiz.bku.slcommands.impl;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
 import javax.xml.transform.Result;
+import javax.xml.transform.Templates;
 import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
 import javax.xml.transform.TransformerException;
-import javax.xml.transform.stream.StreamResult;
-import javax.xml.transform.stream.StreamSource;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXTransformerFactory;
+import javax.xml.transform.sax.TransformerHandler;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.w3c.dom.Node;
 
+import at.buergerkarte.namespaces.securitylayer._1.ErrorResponseType;
+import at.buergerkarte.namespaces.securitylayer._1.ObjectFactory;
 import at.gv.egiz.bku.slcommands.SLCommandFactory;
 import at.gv.egiz.bku.slcommands.SLResult;
+import at.gv.egiz.bku.slexceptions.SLBindingException;
+import at.gv.egiz.bku.slexceptions.SLCommandException;
+import at.gv.egiz.bku.slexceptions.SLException;
+import at.gv.egiz.bku.slexceptions.SLRuntimeException;
 
 /**
  * This class serves as an abstract base class for the implementation of a
@@ -72,46 +81,135 @@ public abstract class SLResultImpl implements SLResult {
     return resultingMimeType;
   }
 
+  private Marshaller getMarshaller() {
+    try {
+      JAXBContext context  = SLCommandFactory.getJaxbContext();
+      Marshaller marshaller = context.createMarshaller();
+      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+      return marshaller;
+    } catch (JAXBException e) {
+      log.fatal("Failed to marshall error response.", e);
+      throw new SLRuntimeException("Failed to marshall error response.", e);
+    }
+  }
+
+  private TransformerHandler getTransformerHandler(Templates templates, Result result) throws SLException {
+    try {
+      SAXTransformerFactory transformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
+      TransformerHandler transformerHandler = transformerFactory.newTransformerHandler(templates);
+      transformerHandler.setResult(result);
+      return transformerHandler;
+    } catch (TransformerFactoryConfigurationError e) {
+      log.error("Failed to create an instance of SAXTransformerFactory.", e);
+      throw new SLBindingException(2000);
+    } catch (IllegalArgumentException e) {
+      log.error("Failed to set result for transformation.", e);
+      throw new SLBindingException(2000);
+    } catch (TransformerConfigurationException e) {
+      log.info("Failed to create an instance of SAXTransformerFactory.", e);
+      throw new SLBindingException(2008);
+    }
+  }
+
+  @Override
+  public void writeTo(Result result) {
+    writeTo(result, null);
+  }
+
+
   /**
-   * Writes the given <code>response</code> to the <code>result</code>.
+   * Writes the given <code>response</code> to the SAX <code>result</code> using
+   * the given transform <code>templates</code>.
    * 
-   * @param response the security layer response element
-   * @param result the result to marshal the response to
+   * @param response
+   * @param result
+   * @param templates
    */
-  @SuppressWarnings("unchecked")
-  public void writeTo(JAXBElement response, Result result) {
+  protected void writeTo(JAXBElement<?> response, Result result, Templates templates) {
 
+    TransformerHandler transformerHandler = null;
+    if (templates != null) {
+      try {
+        transformerHandler = getTransformerHandler(templates, result);
+      } catch (SLException e) {
+        writeErrorTo(e, result, templates);
+      }
+    }
+    
+    Marshaller marshaller = getMarshaller();
     try {
-      JAXBContext context = SLCommandFactory.getJaxbContext();
-      Marshaller marshaller = context.createMarshaller();
-      marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
-      marshaller.marshal(response, result);
+      if (transformerHandler != null) {
+        marshaller.marshal(response, transformerHandler);
+      } else {
+        marshaller.marshal(response, result);
+      }
     } catch (JAXBException e) {
-      // TODO Add throws clause to interface
-      log.fatal("Failed to marshall JAXBElement.", e);
-      throw new RuntimeException("Failed to marshall JAXBElement.", e);
+      log.info("Failed to marshall " + response.getName() + " result." , e);
+      SLCommandException commandException = new SLCommandException(4000);
+      writeErrorTo(commandException, result, templates);
     }
+    
+  }
+  
+  protected void writeTo(Node node, Result result, Templates templates) {
 
+    if (templates == null) {
+      try {
+        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        Transformer transformer = transformerFactory.newTransformer();
+        transformer.transform(new DOMSource(node), result);
+      } catch (TransformerConfigurationException e) {
+        log.error("Failed to create Transformer.", e);
+        writeErrorTo(new SLException(4000), result, null);
+      } catch (TransformerException e) {
+        log.error("Failed to transform result.", e);
+        writeErrorTo(new SLException(4000), result, null);
+      }
+    } else {
+      try {
+        Transformer transformer = templates.newTransformer();
+        transformer.transform(new DOMSource(node), result);
+      } catch (TransformerConfigurationException e) {
+        log.info("Failed to create transformer.", e);
+        writeErrorTo(new SLException(2008), result, templates);
+      } catch (TransformerException e) {
+        log.error("Failed to transform result.", e);
+        writeErrorTo(new SLException(2008), result, templates);
+      }
+    }
+    
   }
+  
+  protected void writeErrorTo(SLException slException, Result result, Templates templates) {
+    
+    TransformerHandler transformerHandler = null;
+    if (templates != null) {
+      try {
+        transformerHandler = getTransformerHandler(templates, result);
+      } catch (SLException e) {
+        // write the exception thrown instead of the given one
+        slException = e;
+      }
+    }
 
-  /* (non-Javadoc)
-   * @see at.gv.egiz.bku.slcommands.SLResult#writeTo(javax.xml.transform.Result, javax.xml.transform.Transformer)
-   */
-  @Override
-  public void writeTo(Result result, Transformer transformer) throws TransformerException {
-    // TODO Auto-generated method stub
-    // fixxme: wb added for testing purposes to be completed
-    // begin hack
-    if (transformer == null) {
-      writeTo(result);
-      return;
+    ObjectFactory factory = new ObjectFactory();
+    ErrorResponseType responseType = factory.createErrorResponseType();
+    responseType.setErrorCode(slException.getErrorCode());
+    responseType.setInfo(slException.getDetailedMsg());
+    JAXBElement<ErrorResponseType> response = factory.createErrorResponse(responseType);
+    
+    Marshaller marshaller = getMarshaller();
+    try {
+      if (transformerHandler != null) {
+        marshaller.marshal(response, transformerHandler);
+      } else {
+        marshaller.marshal(response, result);
+      }
+    } catch (JAXBException e) {
+      log.fatal("Failed to marshall error result." , e);
+      throw new SLRuntimeException("Failed to marshall error result.");
     }
-    // just a quick hack to proceed with testing
-    ByteArrayOutputStream os = new ByteArrayOutputStream();
-    writeTo(new StreamResult(os));
-    ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
-    transformer.transform(new StreamSource(is), result);
-    //end hack
+    
   }
 
 }