added DocumentService

44 files changed, 3494 insertions, 2 deletions

diff --git a/DocumentService/DBSQL/mysql-connector-java-5.1.27-bin.jar b/DocumentService/DBSQL/mysql-connector-java-5.1.27-bin.jar
new file mode 100644
index 000000000..a10268c92
--- /dev/null
+++ b/DocumentService/DBSQL/mysql-connector-java-5.1.27-bin.jar
diff --git a/DocumentService/DBSQL/tables.sql b/DocumentService/DBSQL/tables.sql
new file mode 100644
index 000000000..3fa912357
--- /dev/null
+++ b/DocumentService/DBSQL/tables.sql
@@ -0,0 +1,59 @@
+CREATE DATABASE STORKTRANSFER;
+
+USE STORKTRANSFER;
+
+CREATE TABLE `document` (
+  `DOCID` varchar(255) NOT NULL,
+  `DOCUMENT` longblob,
+  `FILENAME` varchar(255) DEFAULT NULL,
+  `MIMETYPE` longtext,
+  `CREATED` datetime DEFAULT NULL,
+  `UPDATED` datetime DEFAULT NULL,
+  `DELETED` datetime DEFAULT NULL,
+  `RECEIVERCERT` longtext,
+  `ENCKEY` longtext,
+  `ENCIV` longtext,
+  PRIMARY KEY (`DOCID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+
+CREATE TABLE `request` (
+  `REQUESTID` varchar(255) NOT NULL,
+  `DOCID` varchar(255) DEFAULT NULL,
+  `DESTCOUNTRY` varchar(10) NOT NULL,
+  `SPCOUNTRY` varchar(10) NOT NULL,
+  `SPID` varchar(255) NOT NULL,
+  `XMLREQUEST` longtext,
+  `XMLRESPONSE` longtext,
+  `REQTIMESTAMP` datetime DEFAULT NULL,
+  `RESTIMESTAMP` datetime DEFAULT NULL,
+  PRIMARY KEY (`REQUESTID`),
+  KEY `docid_idx` (`DOCID`),
+  CONSTRAINT `docidindex` FOREIGN KEY (`DOCID`) REFERENCES `document` (`DOCID`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `spid` (
+  `ID` int(11) NOT NULL AUTO_INCREMENT,
+  `SPID` varchar(45) NOT NULL,
+  `NAME` varchar(100) DEFAULT NULL,
+  `DESC` varchar(500) DEFAULT NULL,
+  PRIMARY KEY (`ID`)
+) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
+SELECT * FROM STORKTRANSFER.spid;
+
+CREATE TABLE `temp_document` (
+  `DOCID` varchar(255) NOT NULL,
+  `DOCUMENT` longblob,
+  `MIMETYPE` longtext,
+  `CREATED` datetime DEFAULT NULL,
+  `FETCHED` datetime DEFAULT NULL,
+  `DELETED` datetime DEFAULT NULL,
+  `RECEIVERCERT` longtext,
+  `ENCKEY` longtext,
+  `ENCIV` longtext,
+  `SPID` int(11) DEFAULT NULL,
+  PRIMARY KEY (`DOCID`),
+  KEY `SPconstraint_idx` (`SPID`),
+  CONSTRAINT `SPconstraint` FOREIGN KEY (`SPID`) REFERENCES `spid` (`ID`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Temp table for SP documents';
+
diff --git a/DocumentService/TomcatLibs/gmbal-api-only.jar b/DocumentService/TomcatLibs/gmbal-api-only.jar
new file mode 100644
index 000000000..b062fddaf
--- /dev/null
+++ b/DocumentService/TomcatLibs/gmbal-api-only.jar
diff --git a/DocumentService/TomcatLibs/ha-api.jar b/DocumentService/TomcatLibs/ha-api.jar
new file mode 100644
index 000000000..4df68e112
--- /dev/null
+++ b/DocumentService/TomcatLibs/ha-api.jar
diff --git a/DocumentService/TomcatLibs/jaxb-impl-gae.jar b/DocumentService/TomcatLibs/jaxb-impl-gae.jar
new file mode 100644
index 000000000..e02f64839
--- /dev/null
+++ b/DocumentService/TomcatLibs/jaxb-impl-gae.jar
diff --git a/DocumentService/TomcatLibs/jaxb-impl.jar b/DocumentService/TomcatLibs/jaxb-impl.jar
new file mode 100644
index 000000000..77481a426
--- /dev/null
+++ b/DocumentService/TomcatLibs/jaxb-impl.jar
diff --git a/DocumentService/TomcatLibs/jaxws-api.jar b/DocumentService/TomcatLibs/jaxws-api.jar
new file mode 100644
index 000000000..17e7f04cf
--- /dev/null
+++ b/DocumentService/TomcatLibs/jaxws-api.jar
diff --git a/DocumentService/TomcatLibs/jaxws-rt.jar b/DocumentService/TomcatLibs/jaxws-rt.jar
new file mode 100644
index 000000000..6290dd36c
--- /dev/null
+++ b/DocumentService/TomcatLibs/jaxws-rt.jar
diff --git a/DocumentService/TomcatLibs/management-api.jar b/DocumentService/TomcatLibs/management-api.jar
new file mode 100644
index 000000000..f7bbc69a7
--- /dev/null
+++ b/DocumentService/TomcatLibs/management-api.jar
diff --git a/DocumentService/TomcatLibs/policy.jar b/DocumentService/TomcatLibs/policy.jar
new file mode 100644
index 000000000..e688eea41
--- /dev/null
+++ b/DocumentService/TomcatLibs/policy.jar
diff --git a/DocumentService/TomcatLibs/stax-ex.jar b/DocumentService/TomcatLibs/stax-ex.jar
new file mode 100644
index 000000000..1112e3228
--- /dev/null
+++ b/DocumentService/TomcatLibs/stax-ex.jar
diff --git a/DocumentService/TomcatLibs/streambuffer.jar b/DocumentService/TomcatLibs/streambuffer.jar
new file mode 100644
index 000000000..a0f6c985d
--- /dev/null
+++ b/DocumentService/TomcatLibs/streambuffer.jar
diff --git a/DocumentService/WebContent/META-INF/MANIFEST.MF b/DocumentService/WebContent/META-INF/MANIFEST.MF
new file mode 100644
index 000000000..254272e1c
--- /dev/null
+++ b/DocumentService/WebContent/META-INF/MANIFEST.MF
@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+
diff --git a/DocumentService/WebContent/WEB-INF/glassfish-web.xml b/DocumentService/WebContent/WEB-INF/glassfish-web.xml
new file mode 100644
index 000000000..15746b989
--- /dev/null
+++ b/DocumentService/WebContent/WEB-INF/glassfish-web.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE glassfish-web-app PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Servlet 3.0//EN" "http://glassfish.org/dtds/glassfish-web-app_3_0-1.dtd">
+<glassfish-web-app>
+    <context-root>/DocumentService</context-root>
+</glassfish-web-app>
\ No newline at end of file
diff --git a/DocumentService/WebContent/WEB-INF/sun-jaxws.xml b/DocumentService/WebContent/WEB-INF/sun-jaxws.xml
new file mode 100644
index 000000000..06b184d4f
--- /dev/null
+++ b/DocumentService/WebContent/WEB-INF/sun-jaxws.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">
+  <endpoint name="DocumentService" implementation="eu.stork.documentservice.DocumentServiceImpl" url-pattern="/DocumentService" ></endpoint>
+</endpoints>
\ No newline at end of file
diff --git a/DocumentService/WebContent/WEB-INF/web.xml b/DocumentService/WebContent/WEB-INF/web.xml
new file mode 100644
index 000000000..30edc9598
--- /dev/null
+++ b/DocumentService/WebContent/WEB-INF/web.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
+  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+  id="WebApp_ID" version="2.5">
+  <display-name>DocumentService</display-name>
+  <listener>
+    <listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
+  </listener>
+  <servlet>
+    <servlet-name>DocumentService</servlet-name>
+    <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
+    <load-on-startup>1</load-on-startup>
+  </servlet>
+  <servlet-mapping>
+    <servlet-name>DocumentService</servlet-name>
+    <url-pattern>/DocumentService</url-pattern>
+  </servlet-mapping>
+  <session-config>
+    <session-timeout>120</session-timeout>
+  </session-config>
+</web-app>
\ No newline at end of file
diff --git a/DocumentService/build.bat b/DocumentService/build.bat
new file mode 100644
index 000000000..2319129b6
--- /dev/null
+++ b/DocumentService/build.bat
@@ -0,0 +1 @@
+mvn clean install -P embedded 
diff --git a/DocumentService/pom.xml b/DocumentService/pom.xml
new file mode 100644
index 000000000..c93a901ca
--- /dev/null
+++ b/DocumentService/pom.xml
@@ -0,0 +1,138 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>eu.stork</groupId>
+  <artifactId>DocumentService</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <name>DocumentService</name>
+  <description>DTL webservice</description>
+  <dependencies>
+  <!-- log4j -->
+		<dependency>
+			<groupId>log4j</groupId>
+			<artifactId>log4j</artifactId>
+			<version>1.2.17</version>
+			<exclusions>
+				<exclusion>
+					<groupId>javax.jms</groupId>
+					<artifactId>jms</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>com.sun.jdmk</groupId>
+					<artifactId>jmxtools</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>com.sun.jmx</groupId>
+					<artifactId>jmxri</artifactId>
+				</exclusion>
+				<exclusion>
+					<artifactId>mail</artifactId>
+					<groupId>javax.mail</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+  
+  
+  		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.1</version>
+		</dependency>     
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>5.1.27</version>
+		</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.core</groupId>
+			<artifactId>jersey-common</artifactId>
+			<version>2.0-m03</version>
+		</dependency>
+              
+		<dependency>
+			<groupId>org.apache.axis</groupId>
+			<artifactId>axis</artifactId>
+			<version>1.4</version>
+		</dependency>
+<!-- 		<dependency> -->
+<!-- 			<groupId>com.sun.org.apache</groupId> -->
+<!-- 			<artifactId>jaxp-ri</artifactId> -->
+<!-- 			<version>1.4</version> -->
+<!-- 		</dependency> -->
+		<dependency>
+	        <groupId>com.sun.xml.ws</groupId>
+	        <artifactId>jaxws-tools</artifactId>
+	        <version>2.2.8</version>
+      	</dependency>
+      	<dependency>
+    	<groupId>com.sun.xml.ws</groupId>
+		    <artifactId>jaxws-rt</artifactId>
+		    <version>2.2.8</version>
+		    <scope>provided</scope>
+		</dependency>	
+		<dependency>
+			<groupId>javax.xml</groupId>
+			<artifactId>jaxrpc-api</artifactId>
+			<version>1.1</version>
+		</dependency>
+		<!-- Bouncy Castle -->
+		<dependency>
+			<groupId>org.bouncycastle</groupId>
+			<artifactId>bcprov-jdk16</artifactId>
+			<version>1.46</version>
+		</dependency>
+		<dependency>
+			<groupId>com.sun.xml.security</groupId>
+			<artifactId>xml-security-impl</artifactId>
+			<version>1.0</version>
+		</dependency>
+		<dependency>
+	<groupId>org.jvnet</groupId>
+	<artifactId>mimepull</artifactId>
+	<version>1.6</version>
+</dependency>
+<dependency>
+            <groupId>eu.stork</groupId>
+            <artifactId>SamlEngine</artifactId>
+            <version>1.4.0</version>
+        </dependency>
+
+<!-- 		<dependency> -->
+<!-- 			<groupId>MOA.id.server</groupId> -->
+<!-- 			<artifactId>moa-id-lib</artifactId> -->
+<!-- 			<version>2.1.0-RC1</version> -->
+<!-- 			<classifier>classes</classifier> -->
+<!-- 		</dependency> -->
+  </dependencies>
+  <build>
+  <finalName>DocumentService</finalName>
+    <sourceDirectory>src</sourceDirectory>
+    <resources>
+      <resource>
+        <directory>src</directory>
+        <excludes>
+          <exclude>**/*.java</exclude>
+        </excludes>
+      </resource>
+    </resources>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.1</version>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-war-plugin</artifactId>
+        <version>2.3</version>
+        <configuration>
+          <warSourceDirectory>WebContent</warSourceDirectory>
+          <failOnMissingWebXml>false</failOnMissingWebXml>
+          <attachClasses>true</attachClasses>
+        </configuration>
+      </plugin>
+    </plugins>    
+  </build>
+  <packaging>war</packaging>
+</project>
\ No newline at end of file
diff --git a/DocumentService/src/eu/stork/documentservice/DocumentService.java b/DocumentService/src/eu/stork/documentservice/DocumentService.java
new file mode 100644
index 000000000..9c539312e
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/DocumentService.java
@@ -0,0 +1,83 @@
+package eu.stork.documentservice;
+
+import javax.jws.WebMethod;
+import javax.jws.WebService;
+import javax.jws.soap.SOAPBinding;
+import javax.jws.soap.SOAPBinding.Style;
+import javax.jws.soap.SOAPBinding.Use;
+import javax.xml.ws.soap.MTOM;
+
+@MTOM
+@WebService(name = "DocumentService", targetNamespace = "http://stork.eu")
+@SOAPBinding(style = Style.DOCUMENT, use = Use.LITERAL)
+/**
+ * 
+ * @author Advania
+ *
+ */
+public interface DocumentService {
+		
+	/**
+	 * Add document to DTL layer
+	 * @param document the document to add
+	 * @param xmlRequest the original dss xml request
+	 * @param country the destination country 
+	 * @param SpId the sp id
+	 * @param mimeType the document mime type
+	 * @param receiverCert the receiver certificate (for encryption, not implemented now)
+	 * @return the document id (docId)
+	 */
+	@WebMethod(operationName = "addDocument")
+	public String addDocument(byte[] document, String xmlRequest, String country, String SpId, String mimeType, String receiverCert);
+		
+	/**
+	 * Get document from DTL
+	 * @param documentTransferRequest the document transfer request (attribute query saml)
+	 * @param dtlUrl the url of dtl
+	 * @return the document found
+	 */
+	@WebMethod(operationName = "getDocument")
+	public byte[] getDocument(String documentTransferRequest, String dtlUrl);
+	
+	/**
+	 * Get document mime type of document
+	 * @param docId the document id
+	 * @param dtlUrl the url of dtl
+	 * @return the document mime type
+	 */
+	@WebMethod(operationName = "getDocumentMime")
+	public String getDocumentMime(String docId, String dtlUrl);
+		
+	/**
+	 * Update document in dtl
+	 * @param docId the id of document (docId)
+	 * @param xmlResponse the dss xml response 
+	 * @param document the document data
+	 * @return true if successful
+	 */
+	@WebMethod(operationName = "updateDocument")
+	public boolean updateDocument(String docId, String xmlResponse, byte[] document);
+	
+	/**
+	 * Add document to DTL layer which SP has uploaded
+	 * @param docId the document ID of document
+	 * @param xmlRequest the original dss xml request
+	 * @param country the destination country 
+	 * @param SpId the sp id
+	 * @param mimeType the document mime type
+	 * @param receiverCert the receiver certificate (for encryption, not implemented now)
+	 * @return the full document ID
+	 */
+	@WebMethod(operationName = "addSPDocument")
+	public String addSPDocument(String docId, String xmlRequest, String country, String SpId, String receiverCert);
+	
+	/**
+	 * Update document in DTL and prepare for SP
+	 * @param documentTransferRequest the document transfer request (attribute query saml)
+	 * @param dtlUrl the url of the dtl
+	 * @param xmlResponse the xml response
+	 * @return true if successful
+	 */
+	@WebMethod(operationName = "updateSPDocument")
+	public boolean updateSPDocument(String documentTransferRequest, String dtlUrl, String xmlResponse);
+}
diff --git a/DocumentService/src/eu/stork/documentservice/DocumentServiceImpl.java b/DocumentService/src/eu/stork/documentservice/DocumentServiceImpl.java
new file mode 100644
index 000000000..74519dfee
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/DocumentServiceImpl.java
@@ -0,0 +1,522 @@
+package eu.stork.documentservice;
+
+import java.util.Date;
+import java.util.Properties;
+import java.util.UUID;
+
+import javax.jws.WebService;
+import javax.xml.ws.WebServiceException;
+import javax.xml.ws.soap.MTOM;
+
+import org.apache.log4j.Logger;
+
+import com.sun.tools.ws.processor.model.ModelException;
+
+import eu.stork.documentservice.data.DatabaseConnector;
+import eu.stork.documentservice.data.DatabaseConnectorMySQLImpl;
+import eu.stork.documentservice.model.DocumentModel;
+import eu.stork.documentservice.model.RequestModel;
+import eu.stork.documentservice.model.TempDocumentModel;
+import eu.stork.documentservice.utils.ExternalDocservice;
+import eu.stork.documentservice.utils.XmlHelper;
+
+@MTOM(threshold=500)
+@WebService(endpointInterface = "eu.stork.documentservice.DocumentService", targetNamespace = "http://stork.eu", portName = "DocumentServicePort", serviceName = "DocumentService")
+public class DocumentServiceImpl implements DocumentService
+{
+	//final static String PATH = "C:/Temp/upload/";
+	static String COUNTRY;
+	private DatabaseConnector conn;
+	private Properties props = new Properties();
+	private static final Logger LOG = Logger.getLogger(DocumentServiceImpl.class.getName());
+	
+	@Override	
+	public String addDocument(byte[] document, String xmlRequest, String destinationCountry, String SpId, String mimeType, String receiverCert) {
+		String returnMessage = "";
+		if (document != null)
+		{			
+			try 
+			{
+				LOG.trace("Adding document starting, document size: " + Integer.toString(document.length)
+						+ ", destination country: " + destinationCountry + ", SP Id: " + SpId
+						+ ", mime type: " + mimeType + ", receiver cert: " + receiverCert);
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				COUNTRY = props.getProperty("peps.country");
+				RequestModel request = new RequestModel();			
+				request.setDestcountry(destinationCountry);
+				request.setSpcountry(COUNTRY);
+				request.setSpid(SpId);
+				request.setRequestid(XmlHelper.getRequestId(xmlRequest));
+				request.setXmlrequest(xmlRequest);
+				
+				conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+						props.getProperty("sql.server"), props.getProperty("sql.database"));
+				boolean ok = conn.addRequest(request);
+				if (ok)
+				{
+					LOG.trace("Request added.");
+					DocumentModel doc = new DocumentModel();
+					doc.setDocid(UUID.randomUUID().toString());
+					doc.setDocument(document);
+					doc.setMimetype(mimeType);
+					doc.setReicevercert(receiverCert);
+					ok = conn.addDocument(doc);
+					if (ok)
+					{
+						LOG.trace("Document added.");
+						RequestModel req = conn.getRequest(request.getRequestid());
+						if (req != null)
+						{
+							LOG.trace("Request found.");
+							req.setDocid(doc.getDocid());
+							if (conn.updateRequest(req))
+								returnMessage = req.getFullDocID();
+							else
+							{
+								LOG.warn("Could not update request.");
+								throw new WebServiceException("Could not update request.");
+							}
+						}
+					}
+					else
+					{
+						LOG.warn("Could not add document.");
+						throw new WebServiceException("Could not add document.");
+					}
+				}
+				else
+				{
+					LOG.warn("Could not add request.");
+					throw new WebServiceException("Could not add request.");
+				}
+			}
+			catch (ModelException e)
+			{
+				LOG.error("Invalid model in input", e);
+				e.printStackTrace();
+				throw new WebServiceException("Invalid input.", e);
+			}
+			catch (Exception e)
+			{
+				LOG.error("Exception in addDocument.", e);
+				e.printStackTrace();
+				throw new WebServiceException("Upload Failed");
+			}
+			LOG.trace("Add document ending, return message: " + returnMessage);
+			return returnMessage;
+		}
+		else
+			throw new WebServiceException("No document to upload.");
+	}
+
+	@Override
+	public byte[] getDocument(String documentTransferRequest, String dtlUrl) 
+	{		
+		try
+		{
+			String docId = XmlHelper.verifyRequest(documentTransferRequest);
+			if (docId != null && !docId.isEmpty())
+			{			
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				String ownDtlUrl = props.getProperty("docservice.url");
+				LOG.trace("Getting document starting for docId: " + docId);
+				if (dtlUrl != null && !dtlUrl.isEmpty() && !ownDtlUrl.equalsIgnoreCase(dtlUrl))
+				{
+					LOG.trace("Getting document from external DTL for docId: " + docId);
+					byte[] documentData = ExternalDocservice.getDocument(documentTransferRequest, dtlUrl);
+					if (documentData != null)
+					{
+						props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+						conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+								props.getProperty("sql.server"), props.getProperty("sql.database"));
+						DocumentModel doc = conn.getDocument(docId);
+						if (doc != null)
+						{
+							doc.setDocument(documentData);
+							conn.updateDocument(doc);
+						}
+						else
+						{
+							doc = new DocumentModel();
+							doc.setDocid(docId);
+							doc.setDocument(documentData);							
+							doc.setMimetype(ExternalDocservice.getDocumentMime(docId, dtlUrl));
+							//TODO handle cert
+							doc.setReicevercert("");
+							conn.addDocument(doc);
+						}
+					}
+					
+					LOG.trace("Getting document from external DTL ending.");
+					return documentData;
+				}	
+				else
+				{
+					LOG.trace("Getting document from database for docId: " + docId);
+					props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+					conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+							props.getProperty("sql.server"), props.getProperty("sql.database"));
+					DocumentModel doc = conn.getDocument(docId);
+					LOG.trace("Getting document from database ending.");
+					return doc.getDocument();
+				}
+			}
+			else
+			{
+				LOG.warn("Document id is null");
+				throw new WebServiceException("Document Id is null");
+			}			
+		}
+		catch (Exception e)
+		{
+			LOG.error("Exception in getDocument.", e);
+			e.printStackTrace();
+			throw new WebServiceException("Download Failed", e);
+		}
+	}
+	
+	@Override
+	/**
+	 * Get document mime type
+	 */
+	public String getDocumentMime(String docId, String dtlUrl)
+	{
+		try
+		{
+			if (docId != null && !docId.isEmpty())
+			{	
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				String ownDtlUrl = props.getProperty("docservice.url");
+				docId = XmlHelper.StripDocId(docId);
+				LOG.trace("Getting mime starting for docId: " + docId);
+				if (dtlUrl != null && !dtlUrl.isEmpty() && !ownDtlUrl.equalsIgnoreCase(dtlUrl))
+				{					
+					LOG.trace("Getting mime from external DTL for docId: " + docId);
+					String documentMime = ExternalDocservice.getDocumentMime(docId, dtlUrl);
+					if (documentMime != null && !documentMime.isEmpty())
+					{
+						conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+								props.getProperty("sql.server"), props.getProperty("sql.database"));
+						DocumentModel doc = conn.getDocument(docId);
+						if (doc != null)
+						{
+							doc.setMimetype(documentMime);
+							conn.updateDocument(doc);
+						}
+					}
+					LOG.trace("Getting mime from external DTL ending, docId: " + docId + ", mime " + documentMime);
+					return documentMime;
+				}	
+				else
+				{
+					LOG.trace("Getting mime from dabase for docId: " + docId);
+					props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+					conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+							props.getProperty("sql.server"), props.getProperty("sql.database"));
+					DocumentModel doc = conn.getDocument(docId);
+					LOG.trace("Getting mime from database ending, docId: " + docId + ", mime " + doc.getMimetype());
+					return doc.getMimetype();
+				}
+			}
+			else
+			{
+				LOG.warn("Document id is null");
+				throw new WebServiceException("Document Id is null");
+			}			
+		}
+		catch (Exception e)
+		{
+			LOG.error("Exception in getDocumentMime.", e);
+			e.printStackTrace();
+			throw new WebServiceException("Download Failed", e);
+		}
+	}
+	
+	@Override
+	/**
+	 * Update document in document service
+	 */
+	public boolean updateDocument(String docId, String xmlResponse, byte[] document)
+	{
+		boolean success = false;
+		if (docId != null && !docId.isEmpty())
+		{			
+			if (document != null)
+			{
+				try
+				{
+					docId = XmlHelper.StripDocId(docId);
+					LOG.trace("Starting document update for docId: " + docId);
+					props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+					conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+							props.getProperty("sql.server"), props.getProperty("sql.database"));
+					DocumentModel doc = conn.getDocument(docId);
+					if(doc != null)
+					{
+						doc.setDocument(document);
+						success = conn.updateDocument(doc);
+						if (success && xmlResponse != null && !xmlResponse.isEmpty())
+						{
+							RequestModel request = conn.getRequestByDocId(docId);
+							if (request != null)
+							{
+								request.setXmlresponse(xmlResponse);
+								request.setRestimestamp(new Date());
+								success = conn.updateRequest(request);
+							}
+						}
+						LOG.trace("Document " + docId + " updated successfully: " + Boolean.toString(success));
+					}
+					else
+					{
+						LOG.warn("No document found for docId: " + docId);
+						throw new WebServiceException("Document is null");
+					}
+				}
+				catch (Exception e)
+				{
+					LOG.error("Exception in updateDocument.", e);
+					e.printStackTrace();
+					throw new WebServiceException("Update Failed", e);
+				}
+			}
+		}
+		else
+		{
+			LOG.warn("Document id is null");
+			throw new WebServiceException("Document Id is null");
+		}
+		
+		return success;
+	}
+	
+	@Override
+	public String addSPDocument(String docId, String xmlRequest, String destinationCountry, String SpId, String receiverCert) 
+	{
+		String returnMessage = "";
+		if (docId != null && !docId.isEmpty())
+		{
+			try 
+			{
+				LOG.trace("Adding document starting, document ID: " + docId
+						+ ", destination country: " + destinationCountry + ", SP Id: " + SpId
+						+ ", receiver cert: " + receiverCert);
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				COUNTRY = props.getProperty("peps.country");
+				RequestModel request = new RequestModel();			
+				request.setDestcountry(destinationCountry);
+				request.setSpcountry(COUNTRY);
+				request.setSpid(SpId);
+				request.setRequestid(XmlHelper.getRequestId(xmlRequest));
+				request.setXmlrequest(xmlRequest);
+				
+				conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+						props.getProperty("sql.server"), props.getProperty("sql.database"));
+				boolean ok = conn.addRequest(request);
+				if (ok)
+				{
+					LOG.trace("Request added.");
+					LOG.trace("Getting temp document.");
+					TempDocumentModel tempDoc = conn.getTempDocument(docId);
+					if (tempDoc != null)
+					{
+						LOG.trace("Got temp document.");
+						conn.updateTempDocument(tempDoc);
+						LOG.trace("Temp document updated.");
+						DocumentModel doc = new DocumentModel();
+						doc.setDocid(tempDoc.getDocid());
+						doc.setDocument(tempDoc.getDocument());
+						doc.setMimetype(tempDoc.getMimetype());
+						doc.setReicevercert(receiverCert);
+						ok = conn.addDocument(doc);
+						if (ok)
+						{
+							LOG.trace("Document added.");							
+							RequestModel req = conn.getRequest(request.getRequestid());
+							if (req != null)
+							{
+								LOG.trace("Request found.");
+								req.setDocid(doc.getDocid());
+								if (conn.updateRequest(req))
+									returnMessage = req.getFullDocID();
+								else
+								{
+									LOG.warn("Could not update request.");
+									throw new WebServiceException("Could not update request.");
+								}
+							}
+						}
+						else
+						{
+							LOG.warn("Could not add document.");
+							throw new WebServiceException("Could not add document.");
+						}
+					}
+					else
+					{
+						LOG.warn("No document found with id " + docId);
+						throw new WebServiceException("No document found.");
+					}
+				}
+				else
+				{
+					LOG.warn("Could not add request.");
+					throw new WebServiceException("Could not add request.");
+				}
+			}
+			catch (ModelException e)
+			{
+				LOG.error("Invalid model in input", e);
+				e.printStackTrace();
+				throw new WebServiceException("Invalid input.", e);
+			}
+			catch (Exception e)
+			{
+				LOG.error("Exception in addSPDocument.", e);
+				e.printStackTrace();
+				throw new WebServiceException("Upload Failed");
+			}
+			LOG.trace("Add SP document ending, return message: " + returnMessage);
+		}
+		else
+		{
+			LOG.warn("Document id is null");
+			throw new WebServiceException("Document Id is null");
+		}
+		
+		return returnMessage;				
+	}
+	
+	@Override
+	public boolean updateSPDocument(String documentTransferRequest, String dtlUrl, String xmlResponse)
+	{
+		boolean success = false;
+		if (documentTransferRequest != null && !documentTransferRequest.isEmpty())
+		{			
+			if (xmlResponse != null && !xmlResponse.isEmpty())
+			{
+				try
+				{
+					String docId = XmlHelper.verifyRequest(documentTransferRequest);
+					LOG.trace("Document transfer requst ok. Doc ID: " + docId);
+					if (dtlUrl == null || dtlUrl.isEmpty())
+					{
+						LOG.trace("Starting SP document update from database for docId: " + docId);
+						props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+						conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+							props.getProperty("sql.server"), props.getProperty("sql.database"));
+						DocumentModel doc = conn.getDocument(docId);
+						if(doc != null)
+						{
+							TempDocumentModel tempDoc = conn.getTempDocument(docId);
+							tempDoc.setDocument(doc.getDocument());
+							success = conn.updateTempDocument(tempDoc);
+							if (success && xmlResponse != null && !xmlResponse.isEmpty())
+							{
+								RequestModel request = conn.getRequestByDocId(docId);
+								if (request != null)
+								{
+									request.setXmlresponse(xmlResponse);
+									request.setRestimestamp(new Date());
+									if (conn.updateRequest(request))
+									{
+										LOG.trace("Request updated.");
+										success = true;
+									}
+									else
+									{
+										LOG.warn("Could not update request with id " + request.getRequestid());
+										throw new WebServiceException("Update SP document failed");
+									}
+								}
+							}
+							LOG.trace("Document " + docId + " updated successfully: " + Boolean.toString(success));
+						}
+						else
+						{
+							LOG.warn("No document found for docId: " + docId);
+							throw new WebServiceException("Document is null");
+						}
+					}
+					else
+					{
+						LOG.trace("Starting SP document update from external DTL for docId: " + docId);
+						byte[] documentData = ExternalDocservice.getDocument(documentTransferRequest, dtlUrl);
+						if (documentData != null)
+						{
+							props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+							conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+									props.getProperty("sql.server"), props.getProperty("sql.database"));
+							DocumentModel doc = conn.getDocument(docId);
+							if (doc != null)
+							{
+								LOG.trace("Document found");
+								doc.setDocument(documentData);
+								if (conn.updateDocument(doc))
+								{
+									LOG.trace("Document updated");
+									TempDocumentModel tempDoc = conn.getTempDocument(docId);
+									if (tempDoc != null)
+									{
+										LOG.trace("Temp document found");
+										tempDoc.setDocument(documentData);
+										if (conn.updateTempDocument(tempDoc))
+										{
+											LOG.trace("Temp document updated");
+											RequestModel request = conn.getRequestByDocId(docId);
+											request.setXmlresponse(xmlResponse);
+											request.setRestimestamp(new Date());
+											if (conn.updateRequest(request))
+											{
+												LOG.trace("Request updated");
+												success = true;
+											}
+											else
+											{
+												LOG.warn("Could not update request with doc id " + docId);
+												throw new WebServiceException("SP update failed");
+											}
+										}
+										else
+										{
+											LOG.warn("Could not update temp document with id " + docId);
+											throw new WebServiceException("SP update failed");
+										}
+									}
+									else
+									{
+										LOG.warn("Could not find temp document with id " + docId);
+										throw new WebServiceException("SP update failed");
+									}
+								}
+								else
+								{
+									LOG.warn("Could not update document with id " + docId);
+									throw new WebServiceException("SP update failed");
+								}
+							}
+						}
+					}
+				}
+				catch (Exception e)
+				{
+					LOG.error("Exception in updateSPDocument.", e);
+					e.printStackTrace();
+					throw new WebServiceException("Update Failed", e);
+				}
+			}
+			else
+			{
+				LOG.warn("XML signing response is null or empty");
+				throw new WebServiceException("XML signing response is null");
+			}
+		}
+		else
+		{
+			LOG.warn("Document transfer request is null or empty");
+			throw new WebServiceException("Document transfer request is null");
+		}
+		
+		return success;
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/SPDocumentService.java b/DocumentService/src/eu/stork/documentservice/SPDocumentService.java
new file mode 100644
index 000000000..35235c644
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/SPDocumentService.java
@@ -0,0 +1,35 @@
+package eu.stork.documentservice;
+
+import javax.jws.WebMethod;
+import javax.jws.WebService;
+import javax.jws.soap.SOAPBinding;
+import javax.jws.soap.SOAPBinding.Style;
+import javax.jws.soap.SOAPBinding.Use;
+import javax.xml.ws.soap.MTOM;
+
+@MTOM
+@WebService(name = "SPDocumentService", targetNamespace = "http://stork.eu")
+@SOAPBinding(style = Style.DOCUMENT, use = Use.LITERAL)
+/**
+ * 
+ * @author Advania
+ *
+ */
+public interface SPDocumentService {
+
+	/**
+	 * Add document to temp layer
+	 * @param document the document data to add
+	 * @return the document temp id
+	 */
+	@WebMethod(operationName = "addSPSignDocument")
+	public String addSPSignDocument(byte[] document, String spId, String mimeType, String receiverCert);
+		
+	/**
+	 * Get document from Temp layer
+	 * @param docId the document id
+	 * @return the document found
+	 */
+	@WebMethod(operationName = "getSPDocument")
+	public byte[] getSPDocument(String docId, String spId);
+}
diff --git a/DocumentService/src/eu/stork/documentservice/SPDocumentServiceImpl.java b/DocumentService/src/eu/stork/documentservice/SPDocumentServiceImpl.java
new file mode 100644
index 000000000..e89ed8c0c
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/SPDocumentServiceImpl.java
@@ -0,0 +1,126 @@
+package eu.stork.documentservice;
+
+import java.util.Properties;
+import java.util.UUID;
+
+import javax.jws.WebService;
+import javax.xml.ws.WebServiceException;
+import javax.xml.ws.soap.MTOM;
+
+import org.apache.log4j.Logger;
+
+import com.sun.tools.ws.processor.model.ModelException;
+
+import eu.stork.documentservice.data.DatabaseConnector;
+import eu.stork.documentservice.data.DatabaseConnectorMySQLImpl;
+import eu.stork.documentservice.model.TempDocumentModel;
+import eu.stork.documentservice.utils.XmlHelper;
+
+@MTOM(threshold=500)
+@WebService(endpointInterface = "eu.stork.documentservice.SPDocumentService", targetNamespace = "http://stork.eu", portName = "SPDocumentServicePort", serviceName = "SPDocumentService")
+public class SPDocumentServiceImpl implements SPDocumentService {
+
+	static String COUNTRY;
+	private DatabaseConnector conn;
+	private Properties props = new Properties();
+	private static final Logger LOG = Logger.getLogger(DocumentServiceImpl.class.getName());
+	
+	@Override
+	public String addSPSignDocument(byte[] document, String SpId, String mimeType, String receiverCert)
+	{
+		String returnMessage = "";
+		if (document != null)
+		{			
+			try 
+			{
+				LOG.trace("Adding temp document starting, document size: " + Integer.toString(document.length)
+						+ ", SP Id: " + SpId + ", mime type: " + mimeType + " receiver cert: " + receiverCert);
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				COUNTRY = props.getProperty("peps.country");				
+				
+				conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+						props.getProperty("sql.server"), props.getProperty("sql.database"));
+
+				TempDocumentModel doc = new TempDocumentModel();
+				doc.setDocid(UUID.randomUUID().toString());
+				doc.setDocument(document);
+				doc.setSpid(SpId);
+				doc.setMimetype(mimeType);
+				doc.setReicevercert(receiverCert);
+				if (conn.addTempDocument(doc))
+				{
+					LOG.trace("Document added successfully. DocID: " + doc.getDocid());
+					returnMessage = doc.getDocid();
+				}
+				else
+				{
+					LOG.warn("Could not add document.");
+					throw new WebServiceException("Could not add document.");
+				}
+			}
+			catch (ModelException e)
+			{
+				LOG.error("Invalid model in input", e);
+				e.printStackTrace();
+				throw new WebServiceException("Invalid input.", e);
+			}
+			catch (Exception e)
+			{
+				LOG.error("Exception in SP addDocument.", e);
+				e.printStackTrace();
+				throw new WebServiceException("Upload Failed");
+			}
+			LOG.trace("Add document ending, return message: " + returnMessage);
+			return returnMessage;
+		}
+		else
+			throw new WebServiceException("No document to upload.");
+	}
+
+	@Override
+	public byte[] getSPDocument(String docId, String spId) 
+	{
+		try
+		{
+			if (docId != null && !docId.isEmpty())
+			{			
+				LOG.trace("Getting temp document from database for docId: " + docId);
+				docId = XmlHelper.StripDocId(docId);
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				conn = new DatabaseConnectorMySQLImpl(props.getProperty("sql.user"), props.getProperty("sql.password"), 
+						props.getProperty("sql.server"), props.getProperty("sql.database"));
+				TempDocumentModel doc = conn.getTempDocument(docId);
+				if (doc != null)
+				{
+					LOG.trace("Document found.");
+					if (doc.getSpid().equals(spId))
+					{
+						LOG.trace("Getting document from database ending. Document supplied.");
+						return doc.getDocument();
+					}
+					else
+					{
+						LOG.warn("Document SP ID of " + doc.getSpid() + " does not match sent SP ID of " + spId);
+						throw new WebServiceException("Incorrect SP ID."); 
+					}
+				}
+				else
+				{
+					LOG.warn("Document is null");
+					throw new WebServiceException("Document is null.");
+				}
+			}
+			else
+			{
+				LOG.warn("Document id is null or empty.");
+				throw new WebServiceException("Document Id is null");
+			}			
+		}
+		catch (Exception e)
+		{
+			LOG.error("Exception in SP getDocument.", e);
+			e.printStackTrace();
+			throw new WebServiceException("Download Failed", e);
+		}
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/data/DatabaseConnector.java b/DocumentService/src/eu/stork/documentservice/data/DatabaseConnector.java
new file mode 100644
index 000000000..26bd0c405
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/data/DatabaseConnector.java
@@ -0,0 +1,117 @@
+package eu.stork.documentservice.data;
+
+import eu.stork.documentservice.exceptions.DatabaseException;
+import eu.stork.documentservice.model.DocumentModel;
+import eu.stork.documentservice.model.RequestModel;
+import eu.stork.documentservice.model.TempDocumentModel;
+
+public interface DatabaseConnector {
+
+	/**
+	 * Add document to database
+	 * @param document The document model to add
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean addDocument(DocumentModel document)
+			throws DatabaseException;
+
+	/**
+	 * Update document in database
+	 * @param document The document model to update
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean updateDocument(DocumentModel document)
+			throws DatabaseException;
+
+	/**
+	 * Get Document from database
+	 * @param docId Document ID
+	 * @return The document found
+	 * @throws DatabaseException
+	 */
+	public abstract DocumentModel getDocument(String docId)
+			throws DatabaseException;
+
+	/**
+	 * Delete Document from database
+	 * @param docId Document ID
+	 * @return true if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean deleteDocument(String docId)
+			throws DatabaseException;
+
+	/**
+	 * Add request to database
+	 * @param request The request to add
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean addRequest(RequestModel request)
+			throws DatabaseException;
+
+	/**
+	 * Get request from database
+	 * @param requestId The request id
+	 * @return The request found
+	 * @throws DatabaseException
+	 */
+	public abstract RequestModel getRequest(String requestId)
+			throws DatabaseException;
+
+	/**
+	 * Get request from database
+	 * @param docId The document id
+	 * @return The request found
+	 * @throws DatabaseException
+	 */
+	public abstract RequestModel getRequestByDocId(String docId)
+			throws DatabaseException;
+
+	/**
+	 * Update request in database
+	 * @param request The request to update
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean updateRequest(RequestModel request)
+			throws DatabaseException;
+	
+	/**
+	 * Add temp document to database
+	 * @param document The document model to add
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean addTempDocument(TempDocumentModel document)
+			throws DatabaseException;
+	
+	/**
+	 * Get temp document from database
+	 * @param docId Document ID
+	 * @return The document found
+	 * @throws DatabaseException
+	 */
+	public abstract TempDocumentModel getTempDocument(String docId)
+			throws DatabaseException;
+	
+	/**
+	 * Update temp document in database
+	 * @param document The document model to update
+	 * @return True if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean updateTempDocument(TempDocumentModel document)
+			throws DatabaseException;
+	
+	/**
+	 * Delete temp document from database
+	 * @param docId Document ID
+	 * @return true if successful
+	 * @throws DatabaseException
+	 */
+	public abstract boolean deleteTempDocument(String docId)
+			throws DatabaseException; 
+}
\ No newline at end of file
diff --git a/DocumentService/src/eu/stork/documentservice/data/DatabaseConnectorMySQLImpl.java b/DocumentService/src/eu/stork/documentservice/data/DatabaseConnectorMySQLImpl.java
new file mode 100644
index 000000000..bdabc55bf
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/data/DatabaseConnectorMySQLImpl.java
@@ -0,0 +1,713 @@
+package eu.stork.documentservice.data;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import eu.stork.documentservice.exceptions.DatabaseException;
+import eu.stork.documentservice.exceptions.ModelException;
+import eu.stork.documentservice.model.DocumentModel;
+import eu.stork.documentservice.model.RequestModel;
+import eu.stork.documentservice.model.TempDocumentModel;
+
+public class DatabaseConnectorMySQLImpl implements DatabaseConnector {
+	
+	private String user;
+	private String password;
+	private String server;
+	private String database;
+	
+	/**
+	 * The MYSQL connector constructor
+	 * @author sveinbjorno
+	 * @param _user the database user
+	 * @param _password the users password
+	 * @param _server the mysql server
+	 * @param _database the mysql database
+	 */
+	public DatabaseConnectorMySQLImpl(String _user, String _password, String _server, String _database)
+	{
+		user = _user;
+		password = _password;
+		server = _server;
+		database = _database;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#addDocument(eu.stork.documentservice.model.DocumentModel)
+	 */
+	@Override
+	public boolean addDocument(DocumentModel document) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{	
+			document.insertValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("INSERT INTO document(DOCID, DOCUMENT, FILENAME, MIMETYPE, CREATED, RECEIVERCERT, "
+					+ "ENCKEY, ENCIV) VALUES(?, ?, ?, ?, ?, ?, ?, ?)");
+            pst.setString(1, document.getDocid());
+            pst.setBlob(2, document.getDataStream());
+            pst.setString(3, document.getFilename());
+            pst.setString(4, document.getMimetype());
+			pst.setTimestamp(5, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(6, document.getReicevercert());
+			pst.setString(7, document.getEnckey());
+			pst.setString(8, document.getEnciv());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#updateDocument(eu.stork.documentservice.model.DocumentModel)
+	 */
+	@Override
+	public boolean updateDocument(DocumentModel document) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{	
+			document.updateValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("update document set DOCUMENT = ?, FILENAME = ?, MIMETYPE = ?, UPDATED = ?, "
+					+ "RECEIVERCERT = ?, ENCKEY = ?, ENCIV = ? where DOCID = ?");            
+            pst.setBlob(1, document.getDataStream());
+            pst.setString(2, document.getFilename());
+            pst.setString(3, document.getMimetype());
+			pst.setTimestamp(4, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(5, document.getReicevercert());
+			pst.setString(6, document.getEnckey());
+			pst.setString(7, document.getEnciv());
+			pst.setString(8, document.getDocid());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#getDocument(java.lang.String)
+	 */
+	@Override
+	public DocumentModel getDocument(String docId) throws DatabaseException
+	{
+		DocumentModel document = null;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (docId == null || docId.isEmpty())
+				throw new DatabaseException("Document ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "select DOCUMENT, FILENAME, MIMETYPE, CREATED, UPDATED, DELETED, RECEIVERCERT, ENCKEY, ENCIV "
+				+ "from document where DOCID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setString(1, docId);
+            
+			ResultSet set = pst.executeQuery();
+            if (set.next())
+            {
+            	document = new DocumentModel();
+            	document.setDocid(docId);
+            	document.setDataStream(set.getBinaryStream(1));
+            	document.setFilename(set.getString(2));
+            	document.setMimetype(set.getString(3));
+            	document.setCreated(DatabaseHelper.getUtilDate(set.getTimestamp(4)));
+            	document.setUpdated(DatabaseHelper.getUtilDate(set.getTimestamp(5)));
+            	document.setDeleted(DatabaseHelper.getUtilDate(set.getTimestamp(6)));
+            	document.setReicevercert(set.getString(7));
+            	document.setEnckey(set.getString(8));
+            	document.setEnciv(set.getString(9));
+            }
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		
+		return document;		
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#deleteDocument(java.lang.String)
+	 */
+	@Override
+	public boolean deleteDocument(String docId) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (docId == null || docId.isEmpty())
+				throw new DatabaseException("Document ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "update document set document = null, deleted = ? where DOCID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setTimestamp(1, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(2, docId);
+            
+			pst.executeUpdate();
+            successful = true;
+            
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		
+		return successful;		
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#addRequest(eu.stork.documentservice.model.RequestModel)
+	 */
+	@Override
+	public boolean addRequest(RequestModel request) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			request.insertValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("INSERT INTO request(REQUESTID, DOCID, DESTCOUNTRY, SPCOUNTRY, "
+					+ "SPID, XMLREQUEST, REQTIMESTAMP) VALUES(?, ?, ?, ?, ?, ?, ?)");
+            pst.setString(1, request.getRequestid());
+            pst.setString(2, request.getDocid());
+            pst.setString(3, request.getDestcountry());
+            pst.setString(4, request.getSpcountry());
+            pst.setString(5, request.getSpid());
+            pst.setString(6, request.getXmlrequest());
+			pst.setTimestamp(7, DatabaseHelper.getSqlCurrentDate());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#getRequest(java.lang.String)
+	 */
+	@Override
+	public RequestModel getRequest(String requestId) throws DatabaseException
+	{
+		RequestModel request = null;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (requestId == null || requestId.isEmpty())
+				throw new DatabaseException("Request ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "select DOCID, DESTCOUNTRY, SPCOUNTRY, SPID, XMLREQUEST, XMLRESPONSE, REQTIMESTAMP, "
+				+ "RESTIMESTAMP from request where REQUESTID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setString(1, requestId);
+            
+			ResultSet set = pst.executeQuery();
+            if (set.next())
+            {
+            	request = new RequestModel();
+            	request.setRequestid(requestId);
+            	request.setDocid(set.getString(1));
+            	request.setDestcountry(set.getString(2));
+            	request.setSpcountry(set.getString(3));
+            	request.setSpid(set.getString(4));
+            	request.setXmlrequest(set.getString(5));
+            	request.setXmlresponse(set.getString(6));
+            	request.setReqtimestamp(DatabaseHelper.getUtilDate(set.getTimestamp(7)));
+            	request.setRestimestamp(DatabaseHelper.getSqlDate(set.getTimestamp(8)));
+            }
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		
+		return request;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#getRequestByDocId(java.lang.String)
+	 */
+	@Override
+	public RequestModel getRequestByDocId(String docId) throws DatabaseException
+	{
+		RequestModel request = null;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (docId == null || docId.isEmpty())
+				throw new DatabaseException("Document ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "select REQUESTID, DESTCOUNTRY, SPCOUNTRY, SPID, XMLREQUEST, XMLRESPONSE, REQTIMESTAMP, "
+				+ "RESTIMESTAMP from request where DOCID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setString(1, docId);
+            
+			ResultSet set = pst.executeQuery();
+            if (set.next())
+            {
+            	request = new RequestModel();
+            	request.setDocid(docId);
+            	request.setRequestid(set.getString(1));
+            	request.setDestcountry(set.getString(2));
+            	request.setSpcountry(set.getString(3));
+            	request.setSpid(set.getString(4));
+            	request.setXmlrequest(set.getString(5));
+            	request.setXmlresponse(set.getString(6));
+            	request.setReqtimestamp(DatabaseHelper.getUtilDate(set.getTimestamp(7)));
+            	request.setRestimestamp(DatabaseHelper.getSqlDate(set.getTimestamp(8)));
+            }
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		
+		return request;
+	}
+	
+	/* (non-Javadoc)
+	 * @see eu.stork.documentservice.data.DatabaseConnector#updateRequest(eu.stork.documentservice.model.RequestModel)
+	 */
+	@Override
+	public boolean updateRequest(RequestModel request) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			request.updateValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("update request set DOCID = ?, DESTCOUNTRY = ?, SPCOUNTRY = ?, SPID = ?, "
+					+ "XMLREQUEST = ?, XMLRESPONSE = ?, RESTIMESTAMP = ? where REQUESTID = ?");            
+			pst.setString(1, request.getDocid());
+			pst.setString(2, request.getDestcountry());
+            pst.setString(3, request.getSpcountry());
+            pst.setString(4, request.getSpid());
+            pst.setString(5, request.getXmlrequest());
+            pst.setString(6, request.getXmlresponse());
+			pst.setTimestamp(7, DatabaseHelper.getSqlDate(request.getRestimestamp()));
+			pst.setString(8, request.getRequestid());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	@Override
+	public boolean addTempDocument(TempDocumentModel document) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{	
+			document.insertValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("INSERT INTO temp_document(DOCID, DOCUMENT, MIMETYPE, CREATED, RECEIVERCERT, "
+					+ "ENCKEY, ENCIV, SPID) VALUES(?, ?, ?, ?, ?, ?, ?, (SELECT ID FROM spid where spid = ?))");
+            pst.setString(1, document.getDocid());
+            pst.setBlob(2, document.getDataStream());
+            pst.setString(3, document.getMimetype());
+			pst.setTimestamp(4, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(5, document.getReicevercert());
+			pst.setString(6, document.getEnckey());
+			pst.setString(7, document.getEnciv());
+			pst.setString(8, document.getSpid());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	@Override
+	public TempDocumentModel getTempDocument(String docId) throws DatabaseException
+	{
+		TempDocumentModel document = null;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (docId == null || docId.isEmpty())
+				throw new DatabaseException("Document ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "select temp.DOCUMENT, temp.MIMETYPE, temp.CREATED, temp.FETCHED, temp.DELETED, "
+				+ "temp.RECEIVERCERT, temp.ENCKEY, temp.ENCIV, sp.SPID "
+				+ "from temp_document temp inner join spid sp on sp.ID = temp.SPID where DOCID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setString(1, docId);
+            
+			ResultSet set = pst.executeQuery();
+            if (set.next())
+            {
+            	document = new TempDocumentModel();
+            	document.setDocid(docId);
+            	document.setDataStream(set.getBinaryStream(1));
+            	document.setMimetype(set.getString(2));
+            	document.setCreated(DatabaseHelper.getUtilDate(set.getTimestamp(3)));
+            	document.setFetched(DatabaseHelper.getUtilDate(set.getTimestamp(4)));
+            	document.setDeleted(DatabaseHelper.getUtilDate(set.getTimestamp(5)));
+            	document.setReicevercert(set.getString(6));
+            	document.setEnckey(set.getString(7));
+            	document.setEnciv(set.getString(8));
+            	document.setSpid(set.getString(9));
+            }
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return document;
+	}
+	
+	@Override
+	public boolean updateTempDocument(TempDocumentModel document) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{	
+			document.updateValidate();
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);			
+			
+			pst = con.prepareStatement("update temp_document set DOCUMENT = ?, MIMETYPE = ?, FETCHED = ?, "
+					+ "RECEIVERCERT = ?, ENCKEY = ?, ENCIV = ? where DOCID = ?");            
+            pst.setBlob(1, document.getDataStream());
+            pst.setString(2, document.getMimetype());
+			pst.setTimestamp(3, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(4, document.getReicevercert());
+			pst.setString(5, document.getEnckey());
+			pst.setString(6, document.getEnciv());
+			pst.setString(7, document.getDocid());
+            pst.executeUpdate();
+            successful = true;
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		catch (ModelException mex)
+		{
+			throw new DatabaseException(mex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		return successful;
+	}
+	
+	@Override
+	public boolean deleteTempDocument(String docId) throws DatabaseException
+	{
+		boolean successful = false;
+		Connection con = null;
+		PreparedStatement pst = null;
+		
+		try
+		{			
+			if (docId == null || docId.isEmpty())
+				throw new DatabaseException("Document ID is null or empty.");
+			String url = "jdbc:mysql://" + server + "/" + database;
+			con = DriverManager.getConnection(url, user, password);
+			String commandString = "update temp_document set document = null, deleted = ? where DOCID = ?";
+							
+			pst = con.prepareStatement(commandString);
+			pst.setTimestamp(1, DatabaseHelper.getSqlCurrentDate());
+			pst.setString(2, docId);
+            
+			pst.executeUpdate();
+            successful = true;
+            
+		}
+		catch (SQLException ex)
+		{
+			throw new DatabaseException(ex);
+		}
+		finally
+		{
+			try
+			{
+				if (pst != null) {
+	                pst.close();
+	            }
+	            if (con != null) {
+	                con.close();
+	            }
+			}
+			catch (SQLException ex)
+			{
+				throw new DatabaseException(ex);
+			}
+		}
+		
+		return successful;		
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/data/DatabaseHelper.java b/DocumentService/src/eu/stork/documentservice/data/DatabaseHelper.java
new file mode 100644
index 000000000..07c25aeba
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/data/DatabaseHelper.java
@@ -0,0 +1,37 @@
+package eu.stork.documentservice.data;
+
+public class DatabaseHelper {
+	/**
+	 * Get the current timestamp in SQL timestamp
+	 * @return the current time in sql timestamp
+	 */
+	public static java.sql.Timestamp getSqlCurrentDate() {
+	    java.util.Date today = new java.util.Date();
+	    return new java.sql.Timestamp(today.getTime());
+	}
+	
+	/**
+	 * Convert Java Date to SQL timestamp
+	 * @param date the date to convert
+	 * @return the date in sql timestamp
+	 */
+	public static java.sql.Timestamp getSqlDate(java.util.Date date) {
+		if (date != null)
+			return new java.sql.Timestamp(date.getTime());
+		else
+			return null;
+	}
+
+	/**
+	 * Convert SQL timestamp to Java Date
+	 * @param time the timestamp to concert
+	 * @return the time in util date
+	 */
+	public static java.util.Date getUtilDate(java.sql.Timestamp time) {
+		if (time != null)
+			return new java.util.Date(time.getTime());
+		else
+			return null;
+	}
+
+}
diff --git a/DocumentService/src/eu/stork/documentservice/data/docservice.properties b/DocumentService/src/eu/stork/documentservice/data/docservice.properties
new file mode 100644
index 000000000..051738da2
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/data/docservice.properties
@@ -0,0 +1,9 @@
+sql.server=localhost:3306
+sql.database=storktransfer
+sql.user=stork
+sql.password=stork
+
+peps.country=LOCAL
+peps.url=http://mopsos.iaik.tugraz.at:8080/PEPS/GetDSSFileAction
+
+docservice.url=http://mopsos.iaik.tugraz.at:8080/DocumentService/DocumentService
diff --git a/DocumentService/src/eu/stork/documentservice/exceptions/DatabaseException.java b/DocumentService/src/eu/stork/documentservice/exceptions/DatabaseException.java
new file mode 100644
index 000000000..bacca1ded
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/exceptions/DatabaseException.java
@@ -0,0 +1,8 @@
+package eu.stork.documentservice.exceptions;
+
+public class DatabaseException extends Exception {
+	public DatabaseException() { super(); }
+	  public DatabaseException(String message) { super(message); }
+	  public DatabaseException(String message, Throwable cause) { super(message, cause); }
+	  public DatabaseException(Throwable cause) { super(cause); }
+}
diff --git a/DocumentService/src/eu/stork/documentservice/exceptions/DocumentServiceException.java b/DocumentService/src/eu/stork/documentservice/exceptions/DocumentServiceException.java
new file mode 100644
index 000000000..e77da437c
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/exceptions/DocumentServiceException.java
@@ -0,0 +1,9 @@
+package eu.stork.documentservice.exceptions;
+
+public class DocumentServiceException extends Exception {
+	public DocumentServiceException() { super(); }
+	  public DocumentServiceException(String message) { super(message); }
+	  public DocumentServiceException(String message, Throwable cause) { super(message, cause); }
+	  public DocumentServiceException(Throwable cause) { super(cause); }
+
+}
diff --git a/DocumentService/src/eu/stork/documentservice/exceptions/EncryptionException.java b/DocumentService/src/eu/stork/documentservice/exceptions/EncryptionException.java
new file mode 100644
index 000000000..b7557ea96
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/exceptions/EncryptionException.java
@@ -0,0 +1,9 @@
+package eu.stork.documentservice.exceptions;
+
+public class EncryptionException extends Exception {
+	public EncryptionException() { super(); }
+	  public EncryptionException(String message) { super(message); }
+	  public EncryptionException(String message, Throwable cause) { super(message, cause); }
+	  public EncryptionException(Throwable cause) { super(cause); }
+
+}
diff --git a/DocumentService/src/eu/stork/documentservice/exceptions/ModelException.java b/DocumentService/src/eu/stork/documentservice/exceptions/ModelException.java
new file mode 100644
index 000000000..b85f1579b
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/exceptions/ModelException.java
@@ -0,0 +1,8 @@
+package eu.stork.documentservice.exceptions;
+
+public class ModelException extends Exception {
+	public ModelException() { super(); }
+	  public ModelException(String message) { super(message); }
+	  public ModelException(String message, Throwable cause) { super(message, cause); }
+	  public ModelException(Throwable cause) { super(cause); }
+}
diff --git a/DocumentService/src/eu/stork/documentservice/model/DocumentModel.java b/DocumentService/src/eu/stork/documentservice/model/DocumentModel.java
new file mode 100644
index 000000000..10ae8a189
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/model/DocumentModel.java
@@ -0,0 +1,122 @@
+package eu.stork.documentservice.model;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Date;
+
+import eu.stork.documentservice.exceptions.ModelException;
+
+/**
+ * The document model class
+ * @author sveinbjorno
+ *
+ */
+public class DocumentModel {
+	private String docid;
+	private byte[] document;
+	private String filename;
+	private String mimetype;
+	private String reicevercert;	
+	private String enckey;
+	private String enciv;
+	private Date created;
+	private Date updated;
+	private Date deleted;
+	
+	public String getDocid() {
+		return docid;
+	}
+	public void setDocid(String docid) {
+		this.docid = docid;
+	}
+	public byte[] getDocument() {
+		return document;
+	}
+	public void setDocument(byte[] document) {
+		this.document = document;
+	}
+	public String getFilename() {
+		return filename;
+	}
+	public void setFilename(String filename) {
+		this.filename = filename;
+	}
+	public String getMimetype() {
+		return mimetype;
+	}
+	public void setMimetype(String mimetype) {
+		this.mimetype = mimetype;
+	}
+	public String getReicevercert() {
+		return reicevercert;
+	}
+	public void setReicevercert(String reicevercert) {
+		this.reicevercert = reicevercert;		
+	}
+	public String getEnckey() {
+		return enckey;
+	}
+	public void setEnckey(String enckey) {
+		this.enckey = enckey;
+	}
+	public String getEnciv() {
+		return enciv;
+	}
+	public void setEnciv(String enciv) {
+		this.enciv = enciv;
+	}
+	public Date getCreated() {
+		return created;
+	}
+	public void setCreated(Date created) {
+		this.created = created;
+	}
+	public Date getUpdated() {
+		return updated;
+	}
+	public void setUpdated(Date updated) {
+		this.updated = updated;
+	}
+	public Date getDeleted() {
+		return deleted;
+	}
+	public void setDeleted(Date deleted) {
+		this.deleted = deleted;
+	}
+	
+	public InputStream getDataStream()
+	{
+		if (this.document != null)			
+			return new ByteArrayInputStream(this.document);
+		else
+			return null;
+	}
+	
+	public void setDataStream(InputStream stream) throws ModelException
+	{				
+		try {
+			this.document = new byte[stream.available()];
+			stream.read(this.document);
+		} catch (IOException e) {
+			throw new ModelException("Unable to parse stream.", e);
+		}
+	}
+	
+	public void insertValidate() throws ModelException
+	{		
+		if (this.docid == null || this.docid.isEmpty())
+			throw new ModelException("Document ID is null or empty");
+		if (this.document == null)
+			throw new ModelException("Document is null");
+		if (this.mimetype == null || this.mimetype.isEmpty())
+			throw new ModelException("MIME type is null or empty.");
+	}
+	
+	public void updateValidate() throws ModelException
+	{
+		this.insertValidate();
+		if (this.created == null)
+			throw new ModelException("Created is null");
+	}	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/model/RequestModel.java b/DocumentService/src/eu/stork/documentservice/model/RequestModel.java
new file mode 100644
index 000000000..638af419e
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/model/RequestModel.java
@@ -0,0 +1,106 @@
+package eu.stork.documentservice.model;
+
+import java.util.Date;
+
+import eu.stork.documentservice.exceptions.ModelException;
+
+/**
+ * The request model class
+ * @author sveinbjorno
+ *
+ */
+public class RequestModel {
+
+	private String requestid;
+	private String docid;
+	private String destcountry;
+	private String spcountry;
+	private String spid;
+	private String xmlrequest;
+	private String xmlresponse;
+	private Date reqtimestamp;
+	private Date restimestamp;
+	
+	public String getRequestid() {
+		return requestid;
+	}
+	public void setRequestid(String requestid) {
+		this.requestid = requestid;
+	}
+	public String getDocid() {
+		return docid;
+	}
+	public void setDocid(String docid) {
+		this.docid = docid;
+	}
+	public String getDestcountry() {
+		return destcountry;
+	}
+	public void setDestcountry(String destcountry) {
+		this.destcountry = destcountry;
+	}
+	public String getSpcountry() {
+		return spcountry;
+	}
+	public void setSpcountry(String spcountry) {
+		this.spcountry = spcountry;
+	}
+	public String getSpid() {
+		return spid;
+	}
+	public void setSpid(String spid) {
+		this.spid = spid;
+	}
+	public String getXmlrequest() {
+		return xmlrequest;
+	}
+	public void setXmlrequest(String xmlrequest) {
+		this.xmlrequest = xmlrequest;
+	}
+	public String getXmlresponse() {
+		return xmlresponse;
+	}
+	public void setXmlresponse(String xmlresponse) {
+		this.xmlresponse = xmlresponse;
+	}
+	public Date getReqtimestamp() {
+		return reqtimestamp;
+	}
+	public void setReqtimestamp(Date reqtimestamp) {
+		this.reqtimestamp = reqtimestamp;
+	}
+	public Date getRestimestamp() {
+		return restimestamp;
+	}
+	public void setRestimestamp(Date restimestamp) {
+		this.restimestamp = restimestamp;
+	}
+	
+	public String getFullDocID()
+	{
+		return this.spcountry + "/" + this.destcountry + "/" + this.docid;
+	}
+	
+	public void insertValidate() throws ModelException
+	{		
+		if (this.requestid == null || this.requestid.isEmpty())
+			throw new ModelException("Request ID is null or empty");		
+		if (this.destcountry == null || this.destcountry.isEmpty())
+			throw new ModelException("Destination country is null or empty.");
+		if (this.spcountry == null || this.spcountry.isEmpty())
+			throw new ModelException("SP country is null or empty.");
+		if (this.destcountry == null || this.destcountry.isEmpty())
+			throw new ModelException("Destination country is null or empty.");
+		if (this.xmlrequest== null || this.xmlrequest.isEmpty())
+			throw new ModelException("XML request is null or empty.");
+	}
+	
+	public void updateValidate() throws ModelException
+	{
+		this.insertValidate();
+		if (this.docid == null || this.docid.isEmpty())
+			throw new ModelException("Document ID is null or empty");
+		if (this.reqtimestamp == null)
+			throw new ModelException("Request timestamp is null or empty");
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/model/TempDocumentModel.java b/DocumentService/src/eu/stork/documentservice/model/TempDocumentModel.java
new file mode 100644
index 000000000..7c28cc0f7
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/model/TempDocumentModel.java
@@ -0,0 +1,118 @@
+package eu.stork.documentservice.model;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Date;
+
+import eu.stork.documentservice.exceptions.ModelException;
+
+public class TempDocumentModel {
+	private String docid;
+	private byte[] document;
+	private String spid;
+	private String mimetype;
+	private String reicevercert;	
+	private String enckey;
+	private String enciv;
+	private Date created;
+	private Date fetched;
+	private Date deleted;
+	
+	public String getDocid() {
+		return docid;
+	}
+	public void setDocid(String docid) {
+		this.docid = docid;
+	}
+	public byte[] getDocument() {
+		return document;
+	}
+	public void setDocument(byte[] document) {
+		this.document = document;
+	}
+	public String getSpid() {
+		return spid;
+	}
+	public void setSpid(String spid) {
+		this.spid = spid;
+	}	
+	public String getMimetype() {
+		return mimetype;
+	}
+	public void setMimetype(String mimetype) {
+		this.mimetype = mimetype;
+	}
+
+	public String getReicevercert() {
+		return reicevercert;
+	}
+	public void setReicevercert(String reicevercert) {
+		this.reicevercert = reicevercert;		
+	}
+	public String getEnckey() {
+		return enckey;
+	}
+	public void setEnckey(String enckey) {
+		this.enckey = enckey;
+	}
+	public String getEnciv() {
+		return enciv;
+	}
+	public void setEnciv(String enciv) {
+		this.enciv = enciv;
+	}
+	public Date getCreated() {
+		return created;
+	}
+	public void setCreated(Date created) {
+		this.created = created;
+	}
+	public Date getFetched() {
+		return fetched;
+	}
+	public void setFetched(Date fetched) {
+		this.fetched = fetched;
+	}
+	public Date getDeleted() {
+		return deleted;
+	}
+	public void setDeleted(Date deleted) {
+		this.deleted = deleted;
+	}
+	
+	public InputStream getDataStream()
+	{
+		if (this.document != null)			
+			return new ByteArrayInputStream(this.document);
+		else
+			return null;
+	}
+	
+	public void setDataStream(InputStream stream) throws ModelException
+	{				
+		try {
+			this.document = new byte[stream.available()];
+			stream.read(this.document);
+		} catch (IOException e) {
+			throw new ModelException("Unable to parse stream.", e);
+		}
+	}
+	
+	public void insertValidate() throws ModelException
+	{		
+		if (this.docid == null || this.docid.isEmpty())
+			throw new ModelException("Document ID is null or empty");
+		if (this.document == null)
+			throw new ModelException("Document is null");		
+		if (this.spid == null || this.spid.isEmpty())
+			throw new ModelException("SPId is null or empty.");
+	}
+	
+	public void updateValidate() throws ModelException
+	{
+		this.insertValidate();
+		if (this.created == null)
+			throw new ModelException("Created is null");
+	}	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/tests/AttrQueryRequestSdoc.xml b/DocumentService/src/eu/stork/documentservice/tests/AttrQueryRequestSdoc.xml
new file mode 100644
index 000000000..01dbf7317
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/tests/AttrQueryRequestSdoc.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?><saml2p:AttributeQuery xmlns:saml2p="urn:oasis:names:tc:SAML:2.0:protocol" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion" xmlns:stork="urn:eu:stork:names:tc:STORK:1.0:assertion" xmlns:storkp="urn:eu:stork:names:tc:STORK:1.0:protocol" xmlns:xs="http://www.w3.org/2001/XMLSchema" AssertionConsumerServiceURL="http://S-PEPS.gov.xx/PEPS/ColleagueResponse" Consent="urn:oasis:names:tc:SAML:2.0:consent:unspecified" Destination="http://A-PEPS.gov.xx/PEPS/AttributeColleagueRequest" ID="_502bc4db31bb07e54a8b59c6b738dcfc" IssueInstant="2014-01-29T14:04:32.188Z" Version="2.0"><saml2:Issuer Format="urn:oasis:names:tc:SAML:2.0:nameid-format:entity">http://S-PEPS.gov.xx</saml2:Issuer><ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:SignedInfo><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><ds:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/><ds:Reference URI="#_502bc4db31bb07e54a8b59c6b738dcfc"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"><ec:InclusiveNamespaces xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#" PrefixList="xs"/></ds:Transform></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><ds:DigestValue>3F4d8+UWhFgV+WjA3SnBH1xp3k8=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>elOYmXMcuith/nZoqF7NNpBNt8KbUHBVleRcxgMEQwqn4fsebriUFhlbesnIWmJcSKSJetlsVNm+1ZydGjxasTAsz1Nm3K9IVm2gyhXWOqisTfSRcGavJzJuS2MpLvz+O3aa/RbNvDJvDqTD3eGhvfBB/8M/eWNhgQFI5xFFH2DcsW96YtMNafaocHt4lh35+8C4htV3bd8AAD6jzVwN1itBOKivlB048OA3BI9PXdnzLKOfBOXH3TrXpqI06BJpBITFB/teOWLys4p7YH+FejQZgo0mS8+srrRbx+eILqXy+GCujJ8eCJXo2d3JQMcMLqoHaT0Jgj18+QagVkWmiA==</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIDIjCCAgqgAwIBAgIES6idsjANBgkqhkiG9w0BAQUFADBTMQswCQYDVQQGEwJFUzEOMAwGA1UE
+CAwFU3BhaW4xDzANBgNVBAcMBk1hZHJpZDEOMAwGA1UECgwFSW5kcmExEzARBgNVBAMMCmxvY2Fs
+LWRlbW8wHhcNMTMwODI4MTY0NzM1WhcNMTUwODI4MTY0NzM1WjBTMQswCQYDVQQGEwJFUzEOMAwG
+A1UECAwFU3BhaW4xDzANBgNVBAcMBk1hZHJpZDEOMAwGA1UECgwFSW5kcmExEzARBgNVBAMMCmxv
+Y2FsLWRlbW8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx+7zEQUbt8Ot9dByR5TuY
+NPmTwaKhECtnkxYAx9tl+Ga3kFiv+dOSeDoQOhxkICG1ZMaG0Gtk0EQWjscC1cLwDXpAOdhOm5xh
+ndFHxa3V3Y3zomFZA7A3nwP8wt17wDrc1xi2Ye8VrwO7Vjb/F8Rgutlcrvq+LF4g9nQLoRiKUq8w
+NFvDlvhBbLr8hMVBMY/jY7tSQ85qLqKUkWRcoDttJjgWZoO1vpBS4m+FywtYdOoHnN6fv4Dvf1r2
+rNLgebgBvSfwznxiulwW6FBLasYX0rYKP7RfwG8TJ+FumOgAjADj2LdwK25RZNg44XU2V1z1Fp37
+fNXhfo08LpdD1ueFAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBADMRGTWOmadZyCoJNluV+M7LopjC
+9WpFUj76X0cAoNXmt12zYqYe8hjRmBr6l2V/FXT3/TyWET1nILG46zwwAxslw3b2LvkhU+9QcuB8
+yC8TCJJ0kgsTZ/EUZPSbwUG7Nn2jkMiyjlyKcjSCQOzEKQyR1xYwyZG40+BPeGbYjmRgm6kcmCxY
+USWoPwNyfke9gNT80f0pUj7wJ9YwWbTIz1rhf/h7rxoMYypXo+JXwaXW/Ra8v1uDcwfKpE5ZgwAU
+nubLXF4A+H7/N7ZvB5XDwJ4W+99nuPsKfwacD8m1sflTXcEPzzhOq6iQ9anJT94/pMctnp827zXA
+y66jvDrin5I=</ds:X509Certificate></ds:X509Data></ds:KeyInfo></ds:Signature><saml2p:Extensions><stork:QualityAuthenticationAssuranceLevel>3</stork:QualityAuthenticationAssuranceLevel><stork:spCountry>IS</stork:spCountry><storkp:eIDSectorShare>false</storkp:eIDSectorShare><storkp:eIDCrossSectorShare>false</storkp:eIDCrossSectorShare><storkp:eIDCrossBorderShare>false</storkp:eIDCrossBorderShare><storkp:RequestedAttributes><stork:RequestedAttribute Name="http://www.stork.gov.eu/1.0/docRequest" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri" isRequired="true"><stork:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xs:anyType">IS/IS/fbea6e68-0393-401b-b616-f767fff9418c</stork:AttributeValue></stork:RequestedAttribute></storkp:RequestedAttributes></saml2p:Extensions><saml2:Subject><saml2:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"/></saml2:Subject></saml2p:AttributeQuery>
\ No newline at end of file
diff --git a/DocumentService/src/eu/stork/documentservice/tests/DatabaseTests.java b/DocumentService/src/eu/stork/documentservice/tests/DatabaseTests.java
new file mode 100644
index 000000000..a888f0737
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/tests/DatabaseTests.java
@@ -0,0 +1,265 @@
+package eu.stork.documentservice.tests;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+import java.util.UUID;
+
+import org.junit.Test;
+
+import eu.stork.documentservice.data.DatabaseConnector;
+import eu.stork.documentservice.data.DatabaseConnectorMySQLImpl;
+import eu.stork.documentservice.exceptions.DatabaseException;
+import eu.stork.documentservice.model.DocumentModel;
+import eu.stork.documentservice.model.RequestModel;
+import eu.stork.documentservice.model.TempDocumentModel;
+import eu.stork.documentservice.utils.Utils;
+
+public class DatabaseTests {
+	
+	private String user = "stork";
+	private String password = "stork";
+	private String database = "stork";
+	private String server = "localhost:3306";
+	private String pdfLoc = "C:/Temp/temp.pdf";
+	private String destCountry = "AT";
+	private String spCountry = "IS";
+	private String spId = "Demo-SP";
+	private String xmlrequest = "<xml><data>foo</data>";
+	private String xmlresponse = "<xml><data>foo_signed</data>";
+	private static String docId = "";
+	private static String docId2 = "";
+	private static String reqId = "";
+	
+	public DatabaseTests()
+	{
+		if (docId.isEmpty())
+			docId = UUID.randomUUID().toString();
+		if (docId2.isEmpty())
+			docId2 = UUID.randomUUID().toString();
+		if (reqId.isEmpty())
+			reqId = UUID.randomUUID().toString();
+	}
+
+	@Test
+	//Test adding document
+	public void test1() {
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);		
+		DocumentModel document = new DocumentModel();
+		document.setDocid(docId);
+		document.setDocument(Utils.readData(pdfLoc));
+		document.setFilename("pdfdoc.pdf");
+		document.setMimetype("application/pdf");
+		
+		try
+		{
+			boolean ok = conn.addDocument(document);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test getting document
+	public void test2()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{
+			DocumentModel document = conn.getDocument(docId);
+			assertNotNull(document);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+	
+	@Test
+	//Test updating document
+	public void test3()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{
+			DocumentModel document = conn.getDocument(docId);
+			boolean ok = conn.updateDocument(document);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+	
+	@Test
+	//Test deleting document
+	public void test4()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{
+			boolean ok = conn.deleteDocument(docId);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+	
+	@Test
+	//Test adding new request
+	public void test5()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		RequestModel request = new RequestModel();		
+		request.setRequestid(reqId);
+		request.setDestcountry(destCountry);
+		request.setSpcountry(spCountry);
+		request.setSpid(spId);
+		request.setXmlrequest(xmlrequest);
+		
+		try
+		{
+			boolean ok = conn.addRequest(request);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test getting request
+	public void test6()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		
+		try
+		{
+			RequestModel request = conn.getRequest(reqId);
+			assertNotNull(request);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test updating request
+	public void test7()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+
+		try
+		{
+			RequestModel request = conn.getRequest(reqId);
+			request.setDocid(docId);
+			boolean ok = conn.updateRequest(request);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test getting new request
+	public void test8()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+
+		try
+		{
+			RequestModel request = conn.getRequest(reqId);
+			request.setXmlresponse(xmlresponse);
+			request.setRestimestamp(new Date());
+			boolean ok = conn.updateRequest(request);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	
+	@Test
+	//Test add temp document
+	public void test10()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);		
+		TempDocumentModel document = new TempDocumentModel();
+		document.setDocid(docId2);
+		document.setDocument(Utils.readData(pdfLoc));
+		document.setSpid(spId);
+		//document.setFilename("pdfdoc.pdf");
+		document.setMimetype("application/pdf");
+		
+		try
+		{
+			boolean ok = conn.addTempDocument(document);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test getting temp document
+	public void test11()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{			
+			TempDocumentModel document = conn.getTempDocument(docId2);
+			assertNotNull(document);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+	
+	@Test
+	//Test updating temp document
+	public void test12()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{
+			TempDocumentModel document = conn.getTempDocument(docId2);
+			boolean ok = conn.updateTempDocument(document);
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+	
+	@Test
+	//Test delete temp document
+	public void test13()
+	{
+		DatabaseConnector conn = new DatabaseConnectorMySQLImpl(user, password, server, database);
+		try
+		{
+			boolean ok = conn.deleteTempDocument(docId2);			
+			assertTrue(ok);
+		}
+		catch (DatabaseException ex)
+		{
+			ex.printStackTrace();
+		}		
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/tests/DocumentServiceTests.java b/DocumentService/src/eu/stork/documentservice/tests/DocumentServiceTests.java
new file mode 100644
index 000000000..0d27cf044
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/tests/DocumentServiceTests.java
@@ -0,0 +1,123 @@
+package eu.stork.documentservice.tests;
+
+import static org.junit.Assert.*;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+import javax.xml.ws.BindingProvider;
+import javax.xml.ws.Service;
+import javax.xml.ws.soap.SOAPBinding;
+
+import org.junit.Test;
+
+import eu.stork.documentservice.DocumentService;
+import eu.stork.documentservice.exceptions.DocumentServiceException;
+import eu.stork.documentservice.utils.Utils;
+import eu.stork.documentservice.utils.XmlHelper;
+
+public class DocumentServiceTests {
+
+	private static String xmlrequest = "<dss:SignRequest xmlns:dss=\"urn:oasis:names:tc:dss:1.0:core:schema\" RequestID=\"_d96b62a87d18f1095180b1f44c90b5fd\"><dss:InputDocuments><dss:Document><dss:Base64Data MimeType=\"text/plain\">VGVzdCB0ZXh0</dss:Base64Data></dss:Document></dss:InputDocuments></dss:SignRequest>";
+	private static String docRequstLoc = "C:/Temp/AttrQueryRequestSdoc.xml"; 
+	private static String docRequstLocMod = "C:/Temp/AttrQueryRequestSdocMod.xml";
+	private static String destCountry = "AT";	
+	private static String spID ="DEMO-SP";
+	
+	@Test
+	public void testXmlParsing() {
+		String reqId = null;
+		try {
+			reqId = XmlHelper.getRequestId(xmlrequest);
+		} catch (DocumentServiceException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		assertNotNull(reqId);
+	}
+	
+	@Test
+	public void testXmlParsingDocument() {
+		String doc = null;
+		try {
+			doc = XmlHelper.getRequestDocumentData(xmlrequest);
+		} catch (DocumentServiceException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		assertNotNull(doc);
+	}
+	
+	@Test
+	public void testXmlParsingDocumentMime() {
+		String mime = null;
+		try {
+			mime = XmlHelper.getRequestDocumentMime(xmlrequest);
+		} catch (DocumentServiceException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		assertNotNull(mime);
+	}
+	
+	@Test
+	public void testCheckTransferrequest()
+	{		
+		byte[] docBytes = Utils.readData(docRequstLoc);		
+		try {
+			String docId = XmlHelper.verifyRequestByte(docBytes);
+			assertTrue(!docId.isEmpty());
+		} catch (DocumentServiceException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}		
+	}
+	
+	@Test
+	public void testCheckTransferrequestMod()
+	{		
+		byte[] docBytes = Utils.readData(docRequstLocMod);		
+		try {
+			XmlHelper.verifyRequestByte(docBytes);			
+			fail("testCheckTransferrequestMod(...) should've thrown an DocumentServiceException!");
+		} catch (DocumentServiceException e) {
+			e.printStackTrace();
+			//success("Exception thrown.");
+		}		
+	}
+	
+	@Test
+	public void testAddDocument()
+	{
+		URL url = null;
+		  try {
+		   url = new URL("http://localhost:8080/DocumentService/DocumentService?wsdl");
+		  } catch (MalformedURLException e) {
+		   e.printStackTrace();
+		  }
+		  QName qname = new QName("http://stork.eu",
+		    "DocumentService");
+
+		  Service service = Service.create(url, qname);
+		  DocumentService docservice = service.getPort(DocumentService.class);
+		  
+		  BindingProvider bp = (BindingProvider) docservice;
+	      SOAPBinding binding = (SOAPBinding) bp.getBinding();
+	      binding.setMTOMEnabled(true);
+	      
+	      try
+	      {
+		      String doc = XmlHelper.getRequestDocumentData(xmlrequest);
+		      byte[] docData = Utils.decodeBase64String(doc, false);
+		      String mime = XmlHelper.getRequestDocumentMime(xmlrequest);
+			  String docid = docservice.addDocument(docData, xmlrequest, destCountry, spID, mime, "");	  
+			  assertNotNull(docid);
+	      }
+	      catch (Exception ex)
+	      {
+	    	  ex.printStackTrace();
+	      }
+	}
+
+}
diff --git a/DocumentService/src/eu/stork/documentservice/tests/EncryptionTests.java b/DocumentService/src/eu/stork/documentservice/tests/EncryptionTests.java
new file mode 100644
index 000000000..9ac0862cf
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/tests/EncryptionTests.java
@@ -0,0 +1,63 @@
+package eu.stork.documentservice.tests;
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+
+import eu.stork.documentservice.exceptions.EncryptionException;
+import eu.stork.documentservice.utils.EncryptionHelper;
+import eu.stork.documentservice.utils.Utils;
+
+public class EncryptionTests {
+
+	private String pdfLoc = "C:/Temp/temp.pdf";
+	private String certLocation = "C:/Temp/testcert.pem";
+	private static String encKey;
+	private static String encIv;
+	
+	@Test
+	//Test encrypting some data
+	public void test1() {
+		try {
+			EncryptionHelper enc = new EncryptionHelper();
+			byte[] data = (Utils.readData(pdfLoc));
+			byte[] encdata = enc.encrypt(data);			
+			assertNotNull(encdata);
+		} catch (EncryptionException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	@Test
+	//Test encrypting and decrypting some data
+	public void test2() {
+		try {
+			EncryptionHelper enc = new EncryptionHelper();
+			byte[] data = (Utils.readData(pdfLoc));
+			byte[] encdata = enc.encrypt(data);
+			encKey = enc.getKey();
+			encIv = enc.getIv();
+			
+			EncryptionHelper enc1 = new EncryptionHelper(encKey, encIv);
+			byte[] decdata = enc1.decrypt(encdata);
+			assertTrue(Arrays.equals(data, decdata));
+		} catch (EncryptionException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	//Test encrypting with a certificate
+	public void test3() {
+		try {
+			EncryptionHelper enc = new EncryptionHelper(encKey, encIv);
+			String certString = Utils.readString(certLocation);
+			String secret = enc.encryptWithCert(certString, encKey);
+			assertTrue((secret != null && !secret.isEmpty()));
+		} catch (EncryptionException e) {
+			e.printStackTrace();
+		}
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java b/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java
new file mode 100644
index 000000000..1c55e59e3
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/EncryptionHelper.java
@@ -0,0 +1,182 @@
+package eu.stork.documentservice.utils;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.security.AlgorithmParameters;
+import java.security.PublicKey;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+
+import javax.crypto.*;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import com.sun.org.apache.xml.internal.security.utils.Base64;
+
+import eu.stork.documentservice.exceptions.EncryptionException;
+
+public class EncryptionHelper {
+	
+	private static String key;
+	private static String iv;
+	private static Cipher cipher;
+	
+	public EncryptionHelper() throws EncryptionException
+	{
+		this.generateKeys();
+	}
+	
+	public EncryptionHelper(String inKey, String inIv) throws EncryptionException
+	{
+		this.initKeys(inKey, inIv);
+	}
+	
+	/**
+	 * Generate new symmetric keys
+	 * @throws EncryptionException
+	 */
+	public void generateKeys() throws EncryptionException
+	{
+		try 
+		{
+			KeyGenerator keyGen = KeyGenerator.getInstance("AES");
+			keyGen.init(256);
+			SecretKey secretKey = keyGen.generateKey();
+			cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
+			AlgorithmParameters params = cipher.getParameters();
+			key = Base64.encode(secretKey.getEncoded());
+			iv = Base64.encode(params.getParameterSpec(IvParameterSpec.class).getIV());
+		} 
+		catch (Exception e) 
+		{				
+			e.printStackTrace();
+			throw new EncryptionException("Unable to generate encryption key.", e);
+		}		
+	}
+	
+	/**
+	 * Initialize keys with specified keys
+	 * @param inKey the key to use
+	 * @param inIv the IV to use
+	 * @throws EncryptionException the exception thrown
+	 */
+	public void initKeys(String inKey, String inIv) throws EncryptionException
+	{
+		try 
+		{
+			key = inKey;
+			iv = inIv;
+			SecretKeySpec skeySpec = new SecretKeySpec(Base64.decode(inKey), "AES");
+			cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+			cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(Base64.decode(inIv)));
+		} 
+		catch (Exception e) 
+		{				
+			e.printStackTrace();
+			throw new EncryptionException("Unable to initialize encryption key.", e);
+		}		
+	}
+	
+	/**
+	 * Encrypt data with key
+	 * @param clearData the clear data
+	 * @return the encrypted data
+	 * @throws EncryptionException the exception thrown
+	 */
+	public byte[] encrypt(byte[] clearData) throws EncryptionException
+	{		
+		if (clearData != null)
+		{
+			try
+			{
+				return cipher.doFinal(clearData);
+			}
+			catch (Exception ex)
+			{
+				throw new EncryptionException("Could not decrypt data.", ex);
+			}
+		}
+		else
+			throw new EncryptionException("Clear data is null.");
+	}
+	
+	/**
+	 * Decrypt data with keys
+	 * @param encData the encrypted data
+	 * @return decrypted data
+	 * @throws EncryptionException the exception thrown
+	 */
+	public byte[] decrypt(byte[] encData) throws EncryptionException
+	{
+		if (encData != null)
+		{
+			try
+			{
+				return cipher.doFinal(encData);
+			}
+			catch (Exception ex)
+			{
+				throw new EncryptionException("Could not encrypt data.", ex);
+			}
+		}
+		else
+			throw new EncryptionException("Encrypted data is null.");
+	}
+	
+	/**
+	 * Get the key string
+	 * @return the key
+	 */
+	public String getKey()
+	{
+		return key;
+	}
+	
+	/**
+	 * Get the IV string
+	 * @return the iv
+	 */
+	public String getIv()
+	{
+		return iv; 
+	}
+	
+	/**
+	 * Encrypt string with certificate
+	 * @param certString the PEM formated certificate
+	 * @param input the string to encrypt
+	 * @return encrypted string
+	 * @throws EncryptionException the exception thrown
+	 */
+	public String encryptWithCert(String certString, String input) throws EncryptionException
+	{
+		if (certString != null && !certString.isEmpty())
+		{
+			if (input != null && !input.isEmpty())
+			{
+				try {					
+					certString = certString.replace("-----BEGIN CERTIFICATE-----", "");
+					certString = certString.replace("-----END CERTIFICATE-----", "");
+					InputStream inStream = new ByteArrayInputStream(Base64.decode(certString));
+					CertificateFactory cf = CertificateFactory.getInstance("X.509");
+					X509Certificate cert = (X509Certificate)cf.generateCertificate(inStream);
+					PublicKey pk = cert.getPublicKey();
+					Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+					rsaCipher.init(Cipher.ENCRYPT_MODE, pk);
+					byte[] encrypted = rsaCipher.doFinal(input.getBytes("UTF-8"));
+					return Base64.encode(encrypted);
+				} 
+				catch (Exception e) {
+					e.printStackTrace();
+					throw new EncryptionException("Unabled to encrypt string.", e);
+				}
+			}
+			else
+				throw new EncryptionException("Input is null or empty.");
+		}
+		else
+			throw new EncryptionException("Certificate is null or empty.");
+	}
+	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java b/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java
new file mode 100644
index 000000000..821d636a2
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/ExternalDocservice.java
@@ -0,0 +1,105 @@
+package eu.stork.documentservice.utils;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+import javax.xml.ws.BindingProvider;
+import javax.xml.ws.Service;
+import javax.xml.ws.soap.SOAPBinding;
+
+import eu.stork.documentservice.DocumentService;
+import eu.stork.documentservice.exceptions.DocumentServiceException;
+
+public class ExternalDocservice {
+	
+	/**
+	 * Get document from external DTL
+	 * @param documentTransferRequest the document transfer request (attribute query)
+	 * @param dtlUrl the URL of external DTL
+	 * @return the document found
+	 * @throws DocumentServiceException
+	 */
+	public static byte[] getDocument(String documentTransferRequest, String dtlUrl) throws DocumentServiceException
+	{
+		if (documentTransferRequest != null && !documentTransferRequest.isEmpty())
+		{								
+			if (dtlUrl != null && !dtlUrl.isEmpty())
+			{
+				try 
+				{
+					URL url = new URL(dtlUrl);					
+				  
+					QName qname = new QName("http://stork.eu",
+					    "DocumentService");
+	
+					Service service = Service.create(url, qname);
+					DocumentService docservice = service.getPort(DocumentService.class);
+					  
+					BindingProvider bp = (BindingProvider) docservice;
+				    SOAPBinding binding = (SOAPBinding) bp.getBinding();
+				    binding.setMTOMEnabled(true);
+				      
+				    return docservice.getDocument(documentTransferRequest, dtlUrl);
+				}
+				 catch (MalformedURLException e) {
+					   e.printStackTrace();
+					   throw new DocumentServiceException("DTL url is invalid.", e);
+				 }
+				catch (Exception e) {
+					e.printStackTrace();
+					   throw new DocumentServiceException(e);
+				}
+			}
+			else
+				throw new DocumentServiceException("DTL url is empty.");
+		}
+		else
+			throw new DocumentServiceException("Document transfer request is empty.");
+	}
+
+	/**
+	 * Get document mime from external DTL
+	 * @param docId the document id
+	 * @param dtlUrl the URL of external DTL
+	 * @return the document mime found
+	 * @throws DocumentServiceException
+	 */
+	public static String getDocumentMime(String docId, String dtlUrl) throws DocumentServiceException
+	{
+		if (docId != null && !docId.isEmpty())
+		{								
+			if (dtlUrl != null && !dtlUrl.isEmpty())
+			{
+				try 
+				{
+					URL url = new URL(dtlUrl);					
+				  
+					QName qname = new QName("http://stork.eu",
+					    "DocumentService");
+	
+					Service service = Service.create(url, qname);
+					DocumentService docservice = service.getPort(DocumentService.class);
+					  
+					BindingProvider bp = (BindingProvider) docservice;
+				    SOAPBinding binding = (SOAPBinding) bp.getBinding();
+				    binding.setMTOMEnabled(true);
+				      
+				    return docservice.getDocumentMime(docId, dtlUrl);
+				}
+				 catch (MalformedURLException e) {
+					   e.printStackTrace();
+					   throw new DocumentServiceException("DTL url is invalid.", e);
+				 }
+				catch (Exception e) {
+					e.printStackTrace();
+					   throw new DocumentServiceException(e);
+				}
+			}
+			else
+				throw new DocumentServiceException("DTL url is empty.");
+		}
+		else
+			throw new DocumentServiceException("Document Id is empty.");
+	}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java b/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java
new file mode 100644
index 000000000..b80c63dc2
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/GetDSSFileAction.java
@@ -0,0 +1,84 @@
+package eu.stork.documentservice.utils;
+/*
+ * This work is Open Source and licensed by the European Commission under the
+ * conditions of the European Public License v1.1 
+ *  
+ * (http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1); 
+ * 
+ * any use of this file implies acceptance of the conditions of this license. 
+ * 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.
+ */
+
+
+import org.apache.log4j.Logger;
+import org.bouncycastle.util.encoders.UrlBase64;
+
+import eu.stork.peps.auth.commons.IPersonalAttributeList;
+import eu.stork.peps.auth.commons.PEPSUtil;
+
+import eu.stork.peps.auth.commons.PersonalAttribute;
+import eu.stork.peps.auth.commons.STORKAttrQueryRequest;
+
+//import eu.stork.peps.auth.cpeps.AUCPEPS;
+import eu.stork.peps.auth.engine.STORKSAMLEngine;
+import eu.stork.peps.exceptions.STORKSAMLEngineException;
+
+/**
+ * This Action will be invoked by file transfer in order to validate saml
+ * 
+ * @author Advania
+ * 
+ * @version $Revision: $, $Date: $
+ * 
+ */
+public final class GetDSSFileAction {
+	/**
+	 * Unique identifier. 
+	 */
+	private static final long serialVersionUID = 6233180247896844849L;
+	/**
+	 * Logger object.
+	 */
+	private static final Logger LOG = Logger.getLogger(GetDSSFileAction.class.getName());
+//	public String SAMLRequest;
+//	public String docId;
+	private static final String SAML_INSTANCE = "VIDP";
+
+	public static String processDocRequest(String samlRequest)
+	{		
+		String result = "";
+	    //final Map<String, String> parameters = getHttpRequestParameters();	
+		STORKAttrQueryRequest request;
+		try {
+			request = processDocRequest_(samlRequest);
+			final IPersonalAttributeList pal = request.getPersonalAttributeList();
+		    final PersonalAttribute sdoc = pal.get("docRequest");
+		    if (sdoc != null)
+		    {
+		    	String docId = sdoc.getValue().get(0);
+		    	return docId;
+		    }
+		} catch (final STORKSAMLEngineException e) {
+			e.printStackTrace();
+		}	   		
+		return null;
+	}
+		
+	private static STORKAttrQueryRequest processDocRequest_(String samlRequest) 
+		throws STORKSAMLEngineException{
+
+			// fetch the samlToken from the request
+			final byte[] samlToken =  UrlBase64.decode(samlRequest);			
+	
+			final STORKSAMLEngine engine = STORKSAMLEngine.getInstance(SAML_INSTANCE);
+		      
+			final STORKAttrQueryRequest attrData= engine.validateSTORKAttrQueryRequest(samlToken);
+			//SAMLRequest = new String(samlToken);
+			LOG.trace("Processing doc request done. SAML: " + new String(samlToken));
+			return attrData;											
+	  }	
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/Utils.java b/DocumentService/src/eu/stork/documentservice/utils/Utils.java
new file mode 100644
index 000000000..45072a0be
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/Utils.java
@@ -0,0 +1,172 @@
+package eu.stork.documentservice.utils;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.UrlBase64;
+
+public class Utils {
+	
+	public static boolean saveData(byte[] data, String PATH, String fileName)
+	{
+		boolean ok = false;
+		if (data != null)
+		{
+			try
+			{
+				FileOutputStream fos;
+	            File outputDir = new File(PATH);
+	            File saveFile = new File(outputDir, fileName);
+	            fos = new FileOutputStream(saveFile);
+	            fos.write(data);
+	            fos.flush();
+	            fos.close();
+	            ok = true;
+			}
+			catch (Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+		return ok;
+	}
+	
+	public static byte[] readData(String fileName)
+	{
+		byte[] data = null;
+		
+		if (fileName != "")
+		{
+			try
+			{
+				FileInputStream fis;
+				File inputDir = new File(fileName);
+				fis = new FileInputStream(inputDir);
+				data = new byte[(int)inputDir.length()];
+				fis.read(data);
+				fis.close();
+			}
+			catch (Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+		
+		return data;
+	}
+	
+	public static String readString(String fileName)
+	{
+		File file = new File(fileName);
+		StringBuilder text = new StringBuilder();
+
+		try {
+		    BufferedReader br = new BufferedReader(new FileReader(file));
+		    String line;
+
+		    while ((line = br.readLine()) != null) {
+		        text.append(line);
+		    }
+		    br.close();
+		}
+		catch (Exception e) {
+		   e.printStackTrace();
+		}
+	    return text.toString();
+	}
+	
+	public static InputStream getStream(String string, String codePage) throws UnsupportedEncodingException
+	{
+		return new ByteArrayInputStream(string.getBytes(codePage));
+	}
+	
+	public static String encodeBase64bytes(final byte[] bytes, boolean urlSafe) {
+	      try {
+	    	  if (urlSafe)
+	    		  return new String(UrlBase64.encode(bytes), "UTF8");
+	    	  else
+	    		  return new String(Base64.encode(bytes), "UTF8");
+	      } catch (UnsupportedEncodingException e) {	          
+	          return null;
+	      }
+	  }
+	
+	public static byte[] decodeBase64String(final String base64string, boolean urlSave) {
+		if (urlSave)
+			return UrlBase64.decode(base64string);
+		else
+			return Base64.decode(base64string);
+	}
+	
+	// HTTP GET request
+	public static String sendGet(String url) throws Exception 
+	{ 
+		URL obj = new URL(url);
+		HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+	 
+		// optional default is GET
+		con.setRequestMethod("GET");
+	 
+			//add request header
+		con.setRequestProperty("User-Agent", "unknown");
+	 
+		//int responseCode = con.getResponseCode();
+		
+		BufferedReader in = new BufferedReader(
+				new InputStreamReader(con.getInputStream()));
+		String inputLine;
+		StringBuffer response = new StringBuffer();
+	 
+		while ((inputLine = in.readLine()) != null) {
+			response.append(inputLine);
+		}
+		in.close();
+	 
+		return response.toString();
+	 
+		}
+	 
+		// HTTP POST request
+		public static String sendPost(String url, String urlParameters) throws Exception
+		{
+	 		URL obj = new URL(url);
+			HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+	 
+			//add request header
+			con.setRequestMethod("POST");
+			con.setRequestProperty("User-Agent", "unknown");
+			con.setRequestProperty("Accept-Language", "en-US,en;q=0.5");
+	 
+			// Send post request
+			con.setDoOutput(true);
+			DataOutputStream wr = new DataOutputStream(con.getOutputStream());
+			wr.writeBytes(urlParameters);
+			wr.flush();
+			wr.close();
+	 
+			//int responseCode = con.getResponseCode();
+				 
+			BufferedReader in = new BufferedReader(
+			        new InputStreamReader(con.getInputStream()));
+			String inputLine;
+			StringBuffer response = new StringBuffer();
+	 
+			while ((inputLine = in.readLine()) != null) {
+				response.append(inputLine);
+			}
+			in.close();
+	 
+			return response.toString();
+		}
+}
diff --git a/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java b/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java
new file mode 100644
index 000000000..cd325db2e
--- /dev/null
+++ b/DocumentService/src/eu/stork/documentservice/utils/XmlHelper.java
@@ -0,0 +1,224 @@
+package eu.stork.documentservice.utils;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Node;
+import org.w3c.dom.Element;
+
+//import at.gv.egovernment.moa.id.protocols.stork2.attributeproviders.GetDSSFileAction;
+
+import eu.stork.documentservice.data.DatabaseConnectorMySQLImpl;
+import eu.stork.documentservice.exceptions.DocumentServiceException;
+
+public class XmlHelper {
+	
+	private static Properties props = new Properties();
+	
+	public static String getRequestId(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance()
+	                    .newDocumentBuilder();
+				Document doc = dBuilder.parse(is);
+				Element reqElement = doc.getDocumentElement();
+				String reqId = reqElement.getAttribute("RequestID"); 
+				return reqId.replace("_", "");
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocument(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance()
+	                    .newDocumentBuilder();
+				Document doc = dBuilder.parse(is);
+				String document = "";
+				Element req = doc.getDocumentElement();
+				NodeList nList0 = req.getChildNodes();
+				for (int i = 0; i < nList0.getLength(); i++)
+				{
+					Node node = nList0.item(i);
+					NodeList nList1 = node.getChildNodes();
+					for (int j = 0; j < nList1.getLength(); j++)
+					{
+						NodeList nList2 = nList1.item(j).getChildNodes();
+						for (int k = 0; k < nList2.getLength(); k++)
+						{
+							Node docNode =nList2.item(k);
+							document = docNode.getTextContent();
+						}
+					}
+				}
+				return document;
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocumentData(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilderFactory xmlFactory = DocumentBuilderFactory.newInstance();
+				DocumentBuilder docBuilder = xmlFactory.newDocumentBuilder();
+				Document xmlDoc = docBuilder.parse(is);
+				XPathFactory xpathFact = XPathFactory.newInstance();
+				XPath xpath = xpathFact.newXPath();
+				return xpath.evaluate("/SignRequest/InputDocuments/Document/Base64Data/text()", xmlDoc);				
+				
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	public static String getRequestDocumentMime(String xmlRequest) throws DocumentServiceException
+	{
+		if (xmlRequest == null || xmlRequest.isEmpty())
+			throw new DocumentServiceException("XML request is empty");
+		else
+		{
+			try
+			{
+				InputStream is = Utils.getStream(xmlRequest, "UTF-8");
+				DocumentBuilderFactory xmlFactory = DocumentBuilderFactory.newInstance();
+				DocumentBuilder docBuilder = xmlFactory.newDocumentBuilder();
+				Document xmlDoc = docBuilder.parse(is);
+				XPathFactory xpathFact = XPathFactory.newInstance();
+				XPath xpath = xpathFact.newXPath();
+				return xpath.evaluate("/SignRequest/InputDocuments/Document/Base64Data/@MimeType", xmlDoc);				
+				
+			}
+			catch (Exception ex)
+			{
+				throw new DocumentServiceException("Unabled to parse xml.", ex);
+			}
+		}
+	}
+	
+	private static String getDocId(String response) throws DocumentServiceException
+	{
+		if (response == null || response.isEmpty())
+			throw new DocumentServiceException("Response is empty");
+		else
+		{
+			if (response.contains("docId"))
+			{
+				int index = response.indexOf("docId");
+				String docText = response.substring(response.indexOf(">" ,index), response.indexOf("<", index));
+				String docId = docText.replaceAll("[<>]", "");	//s:label name="docId" value="%{docId}"/			
+				docId = docId.substring(docId.indexOf("/")+1);
+				docId = docId.substring(docId.indexOf('/')+1);
+				return docId.replace("/", "");
+			}
+			else
+				throw new DocumentServiceException("No document ID in response.");
+		}
+	}
+	
+	/**
+	 * String the document id
+	 * @param docId the document id to strip
+	 * @return the stripped ID
+	 * @throws DocumentServiceException
+	 */
+	public static String StripDocId(String docId) throws DocumentServiceException
+	{
+		if (docId == null || docId.isEmpty())
+			throw new DocumentServiceException("Doc ID is empty");
+		else
+		{
+			docId = docId.substring(docId.indexOf("/")+1);
+			docId = docId.substring(docId.indexOf('/')+1);
+			return docId.replace("/", "");
+		}
+	}
+	
+	public static String verifyRequest(String transferRequest) throws DocumentServiceException
+	{
+		if (transferRequest == null || transferRequest.isEmpty())
+			throw new DocumentServiceException("Transfer request is empty");
+		else
+		{			
+			try {		
+				String docId="";
+				try{
+				
+//				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));	
+//				System.out.println("url:"+props.getProperty("peps.url"));
+				
+//				final byte[] samlToken =  PEPSUtil.decodeSAMLTokenUrlSafe(parameters
+//						.get(PEPSParameters.SAML_REQUEST.toString()));			
+//			
+//					final STORKSAMLEngine engine = STORKSAMLEngine.getInstance("VIDP");
+//				      
+//					final STORKAttrQueryRequest attrData= engine.validateSTORKAttrQueryRequest(samlToken);
+					
+//				String response = Utils.sendPost(props.getProperty("peps.url"), "SAMLRequest=" + transferRequest);
+//				docId=getDocId(response);;
+				docId = GetDSSFileAction.processDocRequest(transferRequest);
+				}catch(Exception e){e.printStackTrace();}
+				return docId;
+				//FIXME
+//				String response = Utils.sendPost(props.getProperty("peps.url"), "SAMLRequest=" + transferRequest);
+//				return getDocId(response);
+			} catch (Exception e) {
+				e.printStackTrace();
+				throw new DocumentServiceException("Could verify request.", e);
+			} 
+		}
+	}
+	
+	public static String verifyRequestByte(byte[] transferRequest) throws DocumentServiceException
+	{
+		if (transferRequest == null)
+			throw new DocumentServiceException("Transfer request is empty");
+		else
+		{			
+			try {				
+				props.load(DatabaseConnectorMySQLImpl.class.getResourceAsStream("docservice.properties"));
+				String response = Utils.sendPost(props.getProperty("peps.url"),"SAMLRequest=" + Utils.encodeBase64bytes(transferRequest, true));
+				return getDocId(response);
+			} catch (Exception e) {
+				e.printStackTrace();
+				throw new DocumentServiceException("Could not read properties.", e);
+			}
+	
+		}
+	}
+}
diff --git a/id/server/idserverlib/pom.xml b/id/server/idserverlib/pom.xml
index 770182a4f..acb1073f2 100644
--- a/id/server/idserverlib/pom.xml
+++ b/id/server/idserverlib/pom.xml
@@ -288,7 +288,12 @@
 			<version>6.1.1</version>

 			<scope>test</scope>

 		</dependency>

-

+		<dependency>

+			<groupId>eu.stork</groupId>

+			<artifactId>DocumentService</artifactId>

+			<version>0.0.1-SNAPSHOT</version>

+			<classifier>classes</classifier>

+		</dependency>

 	</dependencies>

 

 	<build>

diff --git a/id/server/legacy-backup/mw-messages-api/.settings/org.eclipse.jdt.core.prefs b/id/server/legacy-backup/mw-messages-api/.settings/org.eclipse.jdt.core.prefs
index 45a6e0e0d..76393eede 100644
--- a/id/server/legacy-backup/mw-messages-api/.settings/org.eclipse.jdt.core.prefs
+++ b/id/server/legacy-backup/mw-messages-api/.settings/org.eclipse.jdt.core.prefs
@@ -5,4 +5,4 @@ org.eclipse.jdt.core.compiler.compliance=1.5
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.5
+org.eclipse.jdt.core.compiler.source=1.5
\ No newline at end of file