1 files changed, 297 insertions, 0 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
new file mode 100644
index 00000000..0077b7b2
--- /dev/null
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SLResultImpl.java
@@ -0,0 +1,297 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* 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 at.gv.egiz.bku.slcommands.impl;
+
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+import java.util.Locale;
+
+import javax.xml.XMLConstants;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.transform.OutputKeys;
+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.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 javax.xml.transform.stream.StreamResult;
+
+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.SLMarshallerFactory;
+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;
+import at.gv.egiz.bku.slexceptions.SLVersionException;
+import at.gv.egiz.bku.utils.DebugOutputStream;
+import at.gv.egiz.bku.utils.DebugWriter;
+
+/**
+ * This class serves as an abstract base class for the implementation of a
+ * security layer result.
+ * 
+ * @author mcentner
+ */
+public abstract class SLResultImpl implements SLResult {
+
+  /**
+   * Logging facility.
+   */
+  private static Log log = LogFactory.getLog(SLResult.class);
+
+  /**
+   * The security layer result type (default = XML).
+   */
+  protected SLResultType resultType = SLResultType.XML;
+  
+  /**
+   * The security layer result MIME-type (default = <code>text/xml</code>).
+   */
+  protected String resultingMimeType = "text/xml";
+
+  /* (non-Javadoc)
+   * @see at.gv.egiz.bku.slcommands.SLResult#getResultType()
+   */
+  public SLResultType getResultType() {
+    return resultType;
+  }
+
+  /* (non-Javadoc)
+   * @see at.gv.egiz.bku.slcommands.SLResult#getMimeType()
+   */
+  public String getMimeType() {
+    return resultingMimeType;
+  }
+
+  @Override
+  public void writeTo(Result result, boolean fragment) {
+    writeTo(result, null, false);
+  }
+
+  @Override
+  public abstract void writeTo(Result result, Templates templates, boolean fragment);
+
+  private TransformerHandler getTransformerHandler(Templates templates, Result result) throws SLException {
+    try {
+      SAXTransformerFactory transformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
+      transformerFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+      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);
+    }
+  }
+
+  /**
+   * Writes the given <code>response</code> to the SAX <code>result</code> using
+   * the given transform <code>templates</code>.
+   * 
+   * @param response
+   * @param result
+   * @param templates
+   */
+  protected void writeTo(JAXBElement<?> response, Result result, Templates templates, boolean fragment) {
+    
+    DebugWriter dw = null;
+    DebugOutputStream ds = null;
+    if (log.isTraceEnabled() && result instanceof StreamResult) {
+      StreamResult streamResult = (StreamResult) result;
+      if (streamResult.getOutputStream() != null) {
+        ds = new DebugOutputStream(streamResult.getOutputStream());
+        streamResult.setOutputStream(ds);
+      }
+      if (streamResult.getWriter() != null) {
+        dw = new DebugWriter(streamResult.getWriter());
+        streamResult.setWriter(dw);
+      }
+    }
+
+    TransformerHandler transformerHandler = null;
+    if (templates != null) {
+      try {
+        transformerHandler = getTransformerHandler(templates, result);
+      } catch (SLException e) {
+        writeErrorTo(e, result, templates, fragment);
+      }
+    }
+    
+    Marshaller marshaller = SLMarshallerFactory.getInstance().createMarshaller(true);
+    try {
+      if (transformerHandler != null) {
+        marshaller.marshal(response, transformerHandler);
+      } else {
+        marshaller.marshal(response, result);
+      }
+    } catch (JAXBException e) {
+      log.info("Failed to marshall " + response.getName() + " result." , e);
+      SLCommandException commandException = new SLCommandException(4000);
+      writeErrorTo(commandException, result, templates, fragment);
+    }
+    
+    if (ds != null) {
+      try {
+        log.trace("Marshalled result:\n" + new String(ds.getBufferedBytes(), "UTF-8"));
+      } catch (UnsupportedEncodingException e) {
+        log.trace(e.getMessage());
+      }
+    }
+    
+    if (dw != null) {
+      log.trace("Marshalled result:\n" + dw.getBufferedString());
+    }
+    
+  }
+  
+  protected void writeTo(Node node, Result result, Templates templates, boolean fragment) {
+
+    DebugWriter dw = null;
+    DebugOutputStream ds = null;
+    if (log.isTraceEnabled() && result instanceof StreamResult) {
+      StreamResult streamResult = (StreamResult) result;
+      if (streamResult.getOutputStream() != null) {
+        ds = new DebugOutputStream(streamResult.getOutputStream());
+        streamResult.setOutputStream(ds);
+      }
+      if (streamResult.getWriter() != null) {
+        dw = new DebugWriter(streamResult.getWriter());
+        streamResult.setWriter(dw);
+      }
+    }
+
+    if (templates == null) {
+      try {
+        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        Transformer transformer = transformerFactory.newTransformer();
+        if (fragment) {
+          transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+        }
+        transformer.transform(new DOMSource(node), result);
+      } catch (TransformerConfigurationException e) {
+        log.error("Failed to create Transformer.", e);
+        writeErrorTo(new SLException(4000), result, null, fragment);
+      } catch (TransformerException e) {
+        log.error("Failed to transform result.", e);
+        writeErrorTo(new SLException(4000), result, null, fragment);
+      }
+    } else {
+      try {
+        Transformer transformer = templates.newTransformer();
+        if (fragment) {
+          transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+        }
+        transformer.transform(new DOMSource(node), result);
+      } catch (TransformerConfigurationException e) {
+        log.info("Failed to create transformer.", e);
+        writeErrorTo(new SLException(2008), result, templates, fragment);
+      } catch (TransformerException e) {
+        log.error("Failed to transform result.", e);
+        writeErrorTo(new SLException(2008), result, templates, fragment);
+      }
+    }
+
+    if (ds != null) {
+      try {
+        log.trace("Marshalled result:\n" + new String(ds.getBufferedBytes(), "UTF-8"));
+      } catch (UnsupportedEncodingException e) {
+        log.trace(e.getMessage());
+      }
+    }
+    
+    if (dw != null) {
+      log.trace("Marshalled result:\n" + dw.getBufferedString());
+    }
+
+  }
+  
+  protected void writeErrorTo(SLException slException, Result result, Templates templates, boolean fragment) {
+    writeErrorTo(slException, result, templates, Locale.getDefault(), fragment);
+  }
+  
+  protected void writeErrorTo(SLException slException, Result result, Templates templates, Locale locale, boolean fragment) {
+    
+    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;
+      }
+    }
+
+    Object response;
+    
+    Marshaller marshaller;
+    if (slException instanceof SLVersionException
+        && ("http://www.buergerkarte.at/namespaces/securitylayer/20020225#"
+            .equals(((SLVersionException) slException).getNamespaceURI()) || 
+            "http://www.buergerkarte.at/namespaces/securitylayer/20020831#"
+            .equals(((SLVersionException) slException).getNamespaceURI()))) {
+      // issue ErrorResponse in the legacy namespace
+      at.buergerkarte.namespaces.securitylayer._20020225_.ObjectFactory factory 
+          = new at.buergerkarte.namespaces.securitylayer._20020225_.ObjectFactory();
+      at.buergerkarte.namespaces.securitylayer._20020225_.ErrorResponseType errorResponseType = factory
+          .createErrorResponseType();
+      errorResponseType.setErrorCode(BigInteger.valueOf(slException
+          .getErrorCode()));
+      errorResponseType.setInfo(slException.getLocalizedMessage(locale));
+      response = factory.createErrorResponse(errorResponseType);
+      marshaller = SLMarshallerFactory.getInstance().createLegacyMarshaller(true, fragment);
+    } else {
+      ObjectFactory factory = new ObjectFactory();
+      ErrorResponseType responseType = factory.createErrorResponseType();
+      responseType.setErrorCode(slException.getErrorCode());
+      responseType.setInfo(slException.getLocalizedMessage(locale));
+      response = factory.createErrorResponse(responseType);
+      marshaller = SLMarshallerFactory.getInstance().createMarshaller(true, fragment);
+    }
+    
+    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.");
+    }
+    
+  }
+
+}