Merge branch 'moa-2.1-Snapshot' of gitlab.iaik.tugraz.at:afitzek/moa-idspss into moa-2.1-Snapshot

3 files changed, 225 insertions, 109 deletions

diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/MandateRetrievalRequest.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/MandateRetrievalRequest.java
index 1d081fb1c..4d306af22 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/MandateRetrievalRequest.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/MandateRetrievalRequest.java
@@ -13,10 +13,7 @@ import eu.stork.peps.auth.commons.IPersonalAttributeList;
 import eu.stork.peps.auth.commons.PersonalAttribute;
 import eu.stork.peps.auth.commons.PersonalAttributeList;
 import eu.stork.peps.auth.commons.STORKAttrQueryResponse;
-import eu.stork.peps.complex.attributes.CanonicalAddressType;
-import eu.stork.peps.complex.attributes.MandateContentType;
-import eu.stork.peps.complex.attributes.MandateType;
-import eu.stork.peps.complex.attributes.RepresentationPersonType;
+import eu.stork.peps.complex.attributes.*;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -31,6 +28,7 @@ import java.io.StringWriter;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.regex.Pattern;
 
 /**
@@ -95,21 +93,7 @@ public class MandateRetrievalRequest implements IAction {
                 if (currentAttribute.getName().equals("mandateContent")) {
                     MandateContentType mandateContent = getMandateContent(mandateContainer, currentAttribute);
                     attributeList.add(marshallComplexAttribute(currentAttribute, mandateContent));
-
-                    // final Marshaller marshaller = JAXBContext.newInstance(MandateContentType.class).createMarshaller();
-                    // marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
-
-                    // StringWriter stringWriter = new StringWriter();
-
-                    // marshaller.marshal(new JAXBElement<MandateContentType>(new QName("urn:eu:stork:names:tc:STORK:1.0:assertion", "mandateContent"), MandateContentType.class, null, mandateContent), stringWriter);
-
-                    // ArrayList<String> value = new ArrayList<String>();
-                    // value.add(stringWriter.toString());
-
-                    // PersonalAttribute  mandateContentAttribute = new PersonalAttribute("mandateContent", false, value, "Available");
-
-                    // attributeList.add(mandateContentAttribute);
-                } else if (currentAttribute.getName().equals("representative")) {  //  TODO CHECK
+                } else if (currentAttribute.getName().equals("representative")) {  //  TODO CHECK IN DETAIL
                     RepresentationPersonType representative = getRepresentative(mandateContainer, currentAttribute);
                     attributeList.add(marshallComplexAttribute(currentAttribute, representative));
 
@@ -126,32 +110,53 @@ public class MandateRetrievalRequest implements IAction {
 
                 } else if (currentAttribute.getName().equals("legalName")) {
                     String legalName = getLegalName(mandateContainer, currentAttribute);
-                    PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(legalName), "Available");
-                    attributeList.add(personalAttribute);
+                    if (legalName.length() > 0) {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(legalName), AttributeStatusType.AVAILABLE.value()));
+                    } else {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(legalName), AttributeStatusType.NOT_AVAILABLE.value()));
+                    }
                 } else if (currentAttribute.getName().equals("eLPIdentifier")) {
                     String eLPIdentifier = geteLPIdentifier(mandateContainer, currentAttribute);
-                    PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(eLPIdentifier), "Available");
-                    attributeList.add(personalAttribute);
+                    if (eLPIdentifier.length() > 0) {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(eLPIdentifier), AttributeStatusType.AVAILABLE.value()));
+                    } else {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(eLPIdentifier), AttributeStatusType.NOT_AVAILABLE.value()));
+                    }
                 } else if (currentAttribute.getName().equals("type")) {
                     String type = getCompanyType(mandateContainer, currentAttribute);
-                    PersonalAttribute personalAttribute;
                     if (type.length() > 0) {
-                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(type), "Available"));
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(type), AttributeStatusType.AVAILABLE.value()));
                     } else {
-                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(type), "NotAvailable"));
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(type), AttributeStatusType.NOT_AVAILABLE.value()));
+                    }
+                } else if (currentAttribute.getName().equals("status")) {
+                    String status = getCompanyStatus(mandateContainer, currentAttribute);
+                    if (status.length() > 0) {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(status), AttributeStatusType.AVAILABLE.value()));
+                    } else {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(status), AttributeStatusType.NOT_AVAILABLE.value()));
                     }
                 } else if (currentAttribute.getName().equals("translatableType")) {
-                    String translatableType = "";
-                    PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(translatableType), "Available");
-                    attributeList.add(personalAttribute);
+                    String translatableType = getCompanyTranslatableType(mandateContainer, currentAttribute);
+                    if (translatableType.length() > 0) {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(translatableType), AttributeStatusType.AVAILABLE.value()));
+                    } else {
+                        attributeList.add(new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), Arrays.asList(translatableType), AttributeStatusType.NOT_AVAILABLE.value()));
+                    }
                 }
 
             }
 
+
+//            if (attrResponse.getPersonalAttributeList().size() == 0) {
+//                Logger.error("AttributeList empty - could not retrieve attributes");
+//                throw new MOAIDException("stork.16", new Object[]{}); // TODO MESSAGE
+//            }
+
             attrResponse.setPersonalAttributeList(attributeList);
             moaStorkResponse.setSTORKAttrResponse(attrResponse);
 
-            Logger.debug("Attributes " + moaStorkResponse.getStorkAttrQueryResponse().getPersonalAttributeList().size());
+            Logger.debug("Attributes retrieved: " + moaStorkResponse.getStorkAttrQueryResponse().getPersonalAttributeList().size());
 
             // Prepare extended attributes
             Logger.debug("Preparing data container");
@@ -183,17 +188,15 @@ public class MandateRetrievalRequest implements IAction {
     private String geteLPIdentifier(MandateContainer mandateContainer, PersonalAttribute currentAttribute) throws MOAIDException {
         RepresentationPersonType represented = getRepresented(mandateContainer, currentAttribute);
         if (mandateContainer instanceof CorporateBodyMandateContainer) {
-            return represented.getELPIdentifier();
-        } else {
+            return "AT/".concat(represented.getELPIdentifier());
+        } else if (currentAttribute.isRequired()) {
             Logger.error("Cannot provide eLPIdentifier for natural person.");
-            throw new MOAIDException("stork.16", new Object[]{}); // TODO
+            throw new MOAIDException("stork.19", new Object[]{currentAttribute.getName()});
         }
-
+        return "";
     }
 
     private PersonalAttribute marshallComplexAttribute(PersonalAttribute currentAttribute, Object obj) {    // TODO refactor
-
-
         StringWriter stringWriter = new StringWriter();
         try {
             if (obj instanceof MandateContentType) {
@@ -212,22 +215,24 @@ public class MandateRetrievalRequest implements IAction {
 
         } catch (Exception ex) {
             Logger.error("Could not marshall atrribute: " + currentAttribute.getName() + ", " + ex.getMessage());
-            return new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), new ArrayList<String>(), "NotAvailable");
+            return new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), new ArrayList<String>(), AttributeStatusType.NOT_AVAILABLE.value());
         }
         ArrayList<String> value = new ArrayList<String>();
         value.add(stringWriter.toString());
 
-        PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), value, "Available");
-
+        PersonalAttribute personalAttribute = new PersonalAttribute(currentAttribute.getName(), currentAttribute.isRequired(), value, AttributeStatusType.AVAILABLE.value());
         return personalAttribute;
     }
 
 
-    private String mapPowersType(MandateContainer mandateContainer) {    // TODO
-        return "";
-    }
-
-    private String mapCompanyType(MandateContainer mandateContainer) {    // TODO
+    private String mapPowersType(MandateContainer mandateContainer) {
+        if (mandateContainer.getAnnotation().equals("ELGABilateral")) {
+            return "6"; // Health Powers
+        } else if (mandateContainer.getAnnotation().equals("ERsB")) {
+            return "0"; // General Powers
+        } else if (mandateContainer.getAnnotation().equals("GeneralvollmachtBilateral")) {
+            return "0"; // General Powers
+        }
         return "";
     }
 
@@ -236,6 +241,7 @@ public class MandateRetrievalRequest implements IAction {
         RepresentationPersonType representative = getRepresentative(mandateContainer, sourceAttribute);
         RepresentationPersonType represented = getRepresented(mandateContainer, sourceAttribute);
         MandateContentType mandateContent = getMandateContent(mandateContainer, sourceAttribute);
+
         mandateType.setRepresenting(representative);
         mandateType.setRepresented(represented);
         mandateType.setMandateContent(mandateContent);
@@ -247,31 +253,128 @@ public class MandateRetrievalRequest implements IAction {
         RepresentationPersonType represented = getRepresented(mandateContainer, sourceAttribute);
         if (mandateContainer instanceof CorporateBodyMandateContainer) {
             return represented.getName();
-        } else {
+        } else if (sourceAttribute.isRequired()) {
             Logger.error("Cannot provide legalName for natural person.");
-            throw new MOAIDException("stork.16", new Object[]{}); // TODO
+            throw new MOAIDException("stork.19", new Object[]{sourceAttribute.getName()});
         }
+        return "";
     }
 
 
-    private String getCompanyType(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
+    private String getLegalIdentificationType(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
+        if (mandateContainer instanceof CorporateBodyMandateContainer) {
+            return ((CorporateBodyMandateContainer) mandateContainer).getCorpMandatorIdentificationType();
+        } else if (sourceAttribute.isRequired()) {
+            Logger.error("Cannot provide type for natural person.");
+            throw new MOAIDException("stork.19", new Object[]{sourceAttribute.getName()}); // TODO
+        }
+        return "";
+    }
+
+    private String getCompanyStatus(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
         String legalName = getLegalName(mandateContainer, sourceAttribute);
+        if (legalName.contains("in Liquidation") || legalName.contains("in Liqu.")) {
+            return "L"; // liqudation
+        }
+        return "R";
+    }
 
+    private String getCompanyType(String legalName, String legalIdentificationType, PersonalAttribute sourceAttrivbute) throws MOAIDException {
+        // compile patterns for different organisation types
+        // sources: USP, WKO, LexAndTax
+
+        // gmbh patterns
         ArrayList<Pattern> gmbhPatterns = new ArrayList<Pattern>();
-        gmbhPatterns.add(Pattern.compile(".+ gmbh$", Pattern.CASE_INSENSITIVE));
-        gmbhPatterns.add(Pattern.compile(".+ Handelsges\\.m\\.b\\.H\\.$", Pattern.CASE_INSENSITIVE));
-        gmbhPatterns.add(Pattern.compile(".+ Gesellschaft m\\.b\\.H\\.$", Pattern.CASE_INSENSITIVE));
-        gmbhPatterns.add(Pattern.compile(".+ gesmbh$", Pattern.CASE_INSENSITIVE));
-
-        for (Pattern pattern : gmbhPatterns) {
-            if (pattern.matcher(legalName).matches()) {
-                return "GmbH";
+        gmbhPatterns.add(Pattern.compile(".+ GmbH(( in Liquidation)|( in Liqu.)){0,1}$"));
+        gmbhPatterns.add(Pattern.compile(".+ GesmbH$"));
+        gmbhPatterns.add(Pattern.compile(".+ Gesellschaft mit beschränkter Haftung$"));
+        gmbhPatterns.add(Pattern.compile(".+ Ges\\.m\\.b\\.H\\.$"));
+        gmbhPatterns.add(Pattern.compile(".+ G\\.m\\.b\\.H\\.$"));
+        gmbhPatterns.add(Pattern.compile(".+ Handelsges\\.m\\.b\\.H\\.$"));
+        gmbhPatterns.add(Pattern.compile(".+ Gesellschaft m\\.b\\.H\\.$"));
+
+        // ag patterns
+        ArrayList<Pattern> agPatterns = new ArrayList<Pattern>();
+        agPatterns.add(Pattern.compile(".+ AG$"));
+        agPatterns.add(Pattern.compile(".+ Aktiengesellschaft$"));
+
+        // og patterns
+        ArrayList<Pattern> ogPatterns = new ArrayList<Pattern>();
+        ogPatterns.add(Pattern.compile(".+ OG$"));
+        ogPatterns.add(Pattern.compile(".+ OHG$"));
+        ogPatterns.add(Pattern.compile(".+ offene Gesellschaft$"));
+
+        // kg patterns
+        ArrayList<Pattern> kgPatterns = new ArrayList<Pattern>();
+        kgPatterns.add(Pattern.compile(".+ KG$"));
+        kgPatterns.add(Pattern.compile(".+ Kommanditgesellschaft$"));
+
+        // eu patterns
+        ArrayList<Pattern> euPatterns = new ArrayList<Pattern>();
+        euPatterns.add(Pattern.compile(".+ eingetragene Unternehmerin$"));
+        euPatterns.add(Pattern.compile(".+ eingetragener Unternehmer$"));
+        euPatterns.add(Pattern.compile(".+ e\\.U\\.$"));
+
+
+        // company patterns
+        HashMap<String, ArrayList<Pattern>> companyPatterns = new HashMap<String, ArrayList<Pattern>>();
+        companyPatterns.put("GmbH", gmbhPatterns);
+        companyPatterns.put("AG", agPatterns);
+        companyPatterns.put("OG", ogPatterns);
+        companyPatterns.put("KG", kgPatterns);
+        companyPatterns.put("e.U.", euPatterns);
+
+        // iterate over different types of companies and check if the name ending matches
+        if (S2Constants.IDENTIFICATION_TYPE_COMPANY.equals(legalIdentificationType)) {
+            for (String companyType : companyPatterns.keySet()) {
+                for (Pattern pattern : companyPatterns.get(companyType)) {
+                    if (pattern.matcher(legalName).matches()) {
+                        return companyType;
+                    }
+                }
             }
         }
 
+        // check if the subject is association
+        if (S2Constants.IDENTIFICATION_TYPE_ASSOCIATION.equals(legalIdentificationType)) {
+            return "Verein";
+        }
+
+        // check if the subject falls under category of others
+        if (S2Constants.IDENTIFICATION_TYPE_OTHERS.equals(legalIdentificationType)) {
+            return "ERsB";
+        }
+
         return "";
     }
 
+    private String getCompanyType(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
+        // retrieve the registered subject name and identification type
+        String legalName = getLegalName(mandateContainer, sourceAttribute);
+        String legalIdentificationType = getLegalIdentificationType(mandateContainer, sourceAttribute);
+        return getCompanyType(legalName, legalIdentificationType, sourceAttribute);
+    }
+
+    private String getCompanyTranslatableType(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
+        // retrieve first the company type
+        String companyType = getCompanyType(mandateContainer, sourceAttribute);
+
+        // translate company type based on the section 5.6 in STORK 2 D4.11
+        if (companyType.length() == 0) {
+            return "";
+        } else if (companyType.equals("GmbH")) {
+            return "G";
+        } else if (companyType.equals("AG")) {
+            return "A";
+        } else if (companyType.equals("OG")) {
+            return "O";
+        } else if (companyType.equals("KG")) {
+            return "K";
+        } else {
+            return "";
+        }
+    }
+
 
     private RepresentationPersonType getRepresentative(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) {
         RepresentationPersonType representative = new RepresentationPersonType();
@@ -285,16 +388,16 @@ public class MandateRetrievalRequest implements IAction {
         return representative;
     }
 
-    private RepresentationPersonType getRepresented(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) {
+    private RepresentationPersonType getRepresented(MandateContainer mandateContainer, PersonalAttribute sourceAttribute) throws MOAIDException {
         RepresentationPersonType represented = new RepresentationPersonType();
 
         if (mandateContainer instanceof CorporateBodyMandateContainer) {
-            CorporateBodyMandateContainer corporateBodyMandateContainer = (CorporateBodyMandateContainer) mandateContainer;
-            represented.setELPIdentifier(corporateBodyMandateContainer.getCorpMandatorIdentificationValue());
+            CorporateBodyMandateContainer corporateBodyMandateContainer = (CorporateBodyMandateContainer)mandateContainer;
+            represented.setELPIdentifier("AT/" + corporateBodyMandateContainer.getCorpMandatorIdentificationValue());
             represented.setName(corporateBodyMandateContainer.getCorpMandatorFullName());
             represented.setAddress("");
             represented.setCanonicalAddress(new CanonicalAddressType());
-            represented.setType(mapCompanyType(mandateContainer));     // TODO
+            represented.setType(getCompanyType(corporateBodyMandateContainer.corpMandatorFullName, corporateBodyMandateContainer.corpMandatorIdentificationType, sourceAttribute));
         } else if (mandateContainer instanceof PhyPersonMandateContainer) {
             PhyPersonMandateContainer phyPersonMandateContainer = (PhyPersonMandateContainer) mandateContainer;
             represented.setEIdentifier(""); // TODO CALCULATE
@@ -313,13 +416,12 @@ public class MandateRetrievalRequest implements IAction {
         MandateContentType mandateContent = new MandateContentType();
         try {
             XMLGregorianCalendar validFrom = DatatypeFactory.newInstance().newXMLGregorianCalendar(mandateContainer.getMandateValidFrom());
-
             XMLGregorianCalendar validTo = DatatypeFactory.newInstance().newXMLGregorianCalendar(mandateContainer.getMandateValidTo());
             mandateContent.setValidFrom(validFrom);
             mandateContent.setValidTo(validTo);
         } catch (DatatypeConfigurationException dte) {
-            Logger.error("Error converting data from mandate");
-            throw new MOAIDException("stork.16", new Object[]{}); // TODO
+            Logger.error("Error converting date from mandate: " + mandateContainer.getMandateValidFrom() + ", " + mandateContainer.getMandateValidTo());
+            throw new MOAIDException("stork.20", new Object[]{});
         }
 
         mandateContent.setTransactionLimit(BigInteger.valueOf(0)); // TODO
@@ -332,7 +434,7 @@ public class MandateRetrievalRequest implements IAction {
     }
 
     public boolean needAuthentication(IRequest req, HttpServletRequest httpReq, HttpServletResponse httpResp) {
-        return true;  //
+        return true;
     }
 
     public String getDefaultActionName() {
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/S2Constants.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/S2Constants.java
index e332fbc6a..a2deaa572 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/S2Constants.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/S2Constants.java
@@ -35,6 +35,10 @@ public interface S2Constants {
     public static final String MANDATE_MANDATOR_PHYPERS_FAMILYNAME_QUERY = "/mandate:Mandate/mandate:Mandator/persondata:PhysicalPerson/persondata:Name/persondata:FamilyName/text()";
     public static final String MANDATE_MANDATOR_PHYPERS_DATEOFBIRTH_QUERY = "/mandate:Mandate/mandate:Mandator/persondata:PhysicalPerson/persondata:DateOfBirth/text()";
 
+    public static final String IDENTIFICATION_TYPE_COMPANY = "urn:publicid:gv.at:baseid+XFN";
+    public static final String IDENTIFICATION_TYPE_ASSOCIATION = "urn:publicid:gv.at:baseid+XZVR";
+    public static final String IDENTIFICATION_TYPE_OTHERS = "urn:publicid:gv.at:baseid+XERSB";
+
 
 
 }
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/STORKProtocol.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/STORKProtocol.java
index ed9c45126..29148daeb 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/STORKProtocol.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/protocols/stork2/STORKProtocol.java
@@ -9,6 +9,7 @@ import at.gv.egovernment.moa.logging.Logger;
 import eu.stork.peps.auth.commons.*;
 import eu.stork.peps.auth.engine.STORKSAMLEngine;
 import eu.stork.peps.exceptions.STORKSAMLEngineException;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.util.HashMap;
@@ -26,7 +27,7 @@ public class STORKProtocol implements IModulInfo, MOAIDAuthConstants {
     public static final String AUTHENTICATIONREQUEST = "AuthenticationRequest";
     public static final String ATTRIBUTE_COLLECTOR = "AttributeCollector";
     public static final String MANDATERETRIEVALREQUEST = "MandateRetrievalRequest";
-	public static final String CONSENT_EVALUATOR = "ConsentEvaluator";
+    public static final String CONSENT_EVALUATOR = "ConsentEvaluator";
 
     private static HashMap<String, IAction> actions = new HashMap<String, IAction>();
 
@@ -68,7 +69,7 @@ public class STORKProtocol implements IModulInfo, MOAIDAuthConstants {
 
 
         if (AttributeCollector.class.getSimpleName().equals(action) || ConsentEvaluator.class.getSimpleName().equals(action))
-			return STORK2Request;
+            return STORK2Request;
 
 
         if (request.getParameter("SAMLResponse") != null) {        // TODO check attribute collector
@@ -102,57 +103,66 @@ public class STORKProtocol implements IModulInfo, MOAIDAuthConstants {
 
             return STORK2Response;
 
-        }   else  if (request.getParameter("SAMLRequest") != null)  {
-
-        //extract STORK Response from HTTP Request
-        byte[] decSamlToken;
-        try {
-            decSamlToken = PEPSUtil.decodeSAMLToken(request.getParameter("SAMLRequest"));
-        } catch (NullPointerException e) {
-            if (request.getRemoteHost().contains("129.27.142")) {
-                Logger.warn("Availability check by " + request.getRemoteHost() + " on URI: " + request.getRequestURI());
-            } else {
-                Logger.error("Unable to retrieve STORK Request for host: " + request.getRemoteHost() + " and URI: " + request.getRequestURI(), e);
+        } else if (request.getParameter("SAMLRequest") != null) {
+
+            //extract STORK Response from HTTP Request
+            byte[] decSamlToken;
+            try {
+                decSamlToken = PEPSUtil.decodeSAMLToken(request.getParameter("SAMLRequest"));
+            } catch (NullPointerException e) {
+                if (request.getRemoteHost().contains("129.27.142")) {
+                    Logger.warn("Availability check by " + request.getRemoteHost() + " on URI: " + request.getRequestURI());
+                } else {
+                    Logger.error("Unable to retrieve STORK Request for host: " + request.getRemoteHost() + " and URI: " + request.getRequestURI(), e);
+                }
+                throw new MOAIDException("stork.04", null);
             }
-            throw new MOAIDException("stork.04", null);
-        }
 
-        //Get SAMLEngine instance
-        STORKSAMLEngine engine = STORKSAMLEngine.getInstance("VIDP");
-
-        STORKAuthnRequest authnRequest = null;
-        STORKAttrQueryRequest attrRequest = null;
-
-
-        // check if valid authn request is contained
-        try {
-            authnRequest = engine.validateSTORKAuthnRequest(decSamlToken);
-        } catch (STORKSAMLEngineException ex) {
-            Logger.error("Unable to validate Stork AuthenticationRequest: " + ex.getMessage());
-        } catch(ClassCastException e) {
-        	// we do not have a authnRequest
-        	// check if a valid attr request is container
-        	try {
-        		attrRequest = engine.validateSTORKAttrQueryRequest(decSamlToken);
-        	} catch (STORKSAMLEngineException ex) {
-        		Logger.error("Unable to validate Stork AuthenticationRequest: " + ex.getMessage());
-        	}
-        }
+            //Get SAMLEngine instance
+            STORKSAMLEngine engine = STORKSAMLEngine.getInstance("VIDP");
 
-        // if there is no authn or attr request, raise error
-        if ((authnRequest == null) && (attrRequest == null)) {
-            Logger.error("There is no authentication or attribute request contained.");
-            throw new MOAIDException("stork.14", null);
-        }
+            STORKAuthnRequest authnRequest = null;
+            STORKAttrQueryRequest attrRequest = null;
 
-        STORK2Request.setSTORKAuthnRequest(authnRequest);
-        STORK2Request.setSTORKAttrRequest(attrRequest);
-        
 
-        return STORK2Request;
+            // check if valid authn request is contained
+            try {
+                authnRequest = engine.validateSTORKAuthnRequest(decSamlToken);
+            } catch (STORKSAMLEngineException ex) {
+                Logger.error("Unable to validate Stork AuthenticationRequest: " + ex.getMessage());
+            } catch (ClassCastException e) {
+                // we do not have a authnRequest
+                // check if a valid attr request is container
+                try {
+                    attrRequest = engine.validateSTORKAttrQueryRequest(decSamlToken);
+                } catch (STORKSAMLEngineException ex) {
+                    Logger.error("Unable to validate Stork AuthenticationRequest: " + ex.getMessage());
+                }
+            }
+
+            // if there is no authn or attr request, raise error
+            if ((authnRequest == null) && (attrRequest == null)) {
+                Logger.error("There is no authentication or attribute request contained.");
+                throw new MOAIDException("stork.14", null);
+            }
+            // list attributes in the request
+            try {
+                for (PersonalAttribute personalAttribute : authnRequest.getPersonalAttributeList()) {
+                    Logger.debug("Personal attribute found in request: " + personalAttribute.getName() + " isRequired: " + personalAttribute.isRequired());
+                }
+            } catch (Exception e) {
+                Logger.error("Exception, attributes: " + e.getMessage());
+            }
+
+
+            STORK2Request.setSTORKAuthnRequest(authnRequest);
+            STORK2Request.setSTORKAttrRequest(attrRequest);
+
+
+            return STORK2Request;
         } else {
             throw new MOAIDException("stork.14", null);  // TODO Specify message
-            }
+        }
     }
 
     public IAction canHandleRequest(HttpServletRequest request, HttpServletResponse response) {