some code code-style modifications

active code-quality checks!

2 files changed, 110 insertions, 141 deletions

diff --git a/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractCreateQualEidRequestTask.java b/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractCreateQualEidRequestTask.java
index 518f0d24..d1887d5c 100644
--- a/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractCreateQualEidRequestTask.java
+++ b/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractCreateQualEidRequestTask.java
@@ -4,10 +4,27 @@ import java.security.cert.CertificateEncodingException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.message.BasicNameValuePair;
+import org.jose4j.base64url.Base64Url;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
 import at.gv.egiz.eaaf.core.api.idp.IConfigurationWithSP;
-import at.gv.egiz.eaaf.core.api.idp.IspConfiguration;
+import at.gv.egiz.eaaf.core.api.idp.ISpConfiguration;
 import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
 import at.gv.egiz.eaaf.core.exceptions.EaafAuthenticationException;
 import at.gv.egiz.eaaf.core.exceptions.TaskExecutionException;
@@ -23,21 +40,8 @@ import at.gv.egiz.eaaf.modules.auth.sl20.exceptions.SL20Exception;
 import at.gv.egiz.eaaf.modules.auth.sl20.exceptions.SlCommandoParserException;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20Constants;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20HttpBindingUtils;
-import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20JsonExtractorUtils;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20JsonBuilderUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.http.HttpResponse;
-import org.apache.http.NameValuePair;
-import org.apache.http.client.entity.UrlEncodedFormEntity;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.client.utils.URIBuilder;
-import org.apache.http.message.BasicNameValuePair;
-import org.jose4j.base64url.Base64Url;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
+import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20JsonExtractorUtils;
 
 public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServletTask {
   private static final Logger log = LoggerFactory.getLogger(AbstractCreateQualEidRequestTask.class);
@@ -57,7 +61,7 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
 
     try {
       // get service-provider configuration
-      final IspConfiguration oaConfig = pendingReq.getServiceProviderConfiguration();
+      final ISpConfiguration oaConfig = pendingReq.getServiceProviderConfiguration();
 
       if (oaConfig == null) {
         log.warn("No SP configuration in pendingReq!");
@@ -68,16 +72,14 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
       // get basic configuration parameters
       final String vdaQualEidDUrl = extractVdaUrlForSpecificOa(oaConfig, executionContext);
       if (StringUtils.isEmpty(vdaQualEidDUrl)) {
-        log.error("NO VDA URL for qualified eID ("
-            + Constants.CONFIG_PROP_VDA_ENDPOINT_QUALeID_DEFAULT + ")");
-        throw new SL20Exception("sl20.03", new Object[] {"NO VDA URL for qualified eID"});
+        log.error("NO VDA URL for qualified eID (" + Constants.CONFIG_PROP_VDA_ENDPOINT_QUALeID_DEFAULT + ")");
+        throw new SL20Exception("sl20.03", new Object[] { "NO VDA URL for qualified eID" });
 
       }
 
       log.debug("Use {} as VDA end-point", vdaQualEidDUrl);
       pendingReq.setRawDataToTransaction(
-          Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_COMMAND_PARAM_EID_RESULT_CCSURL,
-          vdaQualEidDUrl);
+          Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_COMMAND_PARAM_EID_RESULT_CCSURL, vdaQualEidDUrl);
       revisionsLogger.logEvent(pendingReq, EventCodes.AUTHPROCESS_SL20_ENDPOINT_URL, vdaQualEidDUrl);
 
       // create SL2.0 command for qualified eID
@@ -85,8 +87,8 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
 
       // build request container
       final String qualEidReqId = Random.nextProcessReferenceValue();
-      final ObjectNode sl20Req =
-          SL20JsonBuilderUtils.createGenericRequest(qualEidReqId, null, null, signedQualEidCommand);
+      final ObjectNode sl20Req = SL20JsonBuilderUtils.createGenericRequest(qualEidReqId, null, null,
+          signedQualEidCommand);
 
       // build http POST request
       final HttpPost httpReq = new HttpPost(new URIBuilder(vdaQualEidDUrl).build());
@@ -102,8 +104,7 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
       // HttpGet httpReq = new HttpGet(sl20ReqUri.build());
 
       // set native client header
-      httpReq.addHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE,
-          SL20Constants.HTTP_HEADER_VALUE_NATIVE);
+      httpReq.addHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE, SL20Constants.HTTP_HEADER_VALUE_NATIVE);
 
       log.trace("Request VDA via SL20 with: " + Base64Url.encode(sl20Req.toString().getBytes("UTF-8")));
 
@@ -113,8 +114,7 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
       // parse response
       log.info("Receive response from VDA ... ");
       final JsonNode sl20Resp = SL20JsonExtractorUtils.getSL20ContainerFromResponse(httpResp);
-      final VerificationResult respPayloadContainer =
-          SL20JsonExtractorUtils.extractSL20PayLoad(sl20Resp, null, false);
+      final VerificationResult respPayloadContainer = SL20JsonExtractorUtils.extractSL20PayLoad(sl20Resp, null, false);
 
       if (respPayloadContainer.isValidSigned() == null) {
         log.debug("Receive unsigned payLoad from VDA");
@@ -136,28 +136,27 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
 
         // create forward SL2.0 command
         final ObjectNode sl20Forward = sl20Resp.deepCopy();
-        SL20JsonBuilderUtils.addOnlyOnceOfTwo(sl20Forward, SL20Constants.SL20_PAYLOAD,
-            SL20Constants.SL20_SIGNEDPAYLOAD, command.deepCopy(), signedCommand);
+        SL20JsonBuilderUtils.addOnlyOnceOfTwo(sl20Forward, SL20Constants.SL20_PAYLOAD, SL20Constants.SL20_SIGNEDPAYLOAD,
+            command.deepCopy(), signedCommand);
 
         // store pending request
-        pendingReq.setRawDataToTransaction(
-            Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_REQID, qualEidReqId);
+        pendingReq.setRawDataToTransaction(Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_REQID,
+            qualEidReqId);
         requestStoreage.storePendingRequest(pendingReq);
 
         // forward SL2.0 command
         // TODO: maybe add SL2ClientType Header from execution context
         SL20HttpBindingUtils.writeIntoResponse(request, response, sl20Forward, redirectUrl,
-            Integer
-                .parseInt(authConfig.getBasicConfiguration(Constants.CONFIG_PROP_HTTP_REDIRECT_CODE,
-                    Constants.CONFIG_PROP_HTTP_REDIRECT_CODE_DEFAULT_VALUE)));
+            Integer.parseInt(authConfig.getBasicConfiguration(Constants.CONFIG_PROP_HTTP_REDIRECT_CODE,
+                Constants.CONFIG_PROP_HTTP_REDIRECT_CODE_DEFAULT_VALUE)));
 
       } else if (respPayload.get(SL20Constants.SL20_COMMAND_CONTAINER_NAME).asText()
           .equals(SL20Constants.SL20_COMMAND_IDENTIFIER_ERROR)) {
         JsonNode result = SL20JsonExtractorUtils.getJsonObjectValue(respPayload,
             SL20Constants.SL20_COMMAND_CONTAINER_RESULT, false);
         if (result == null) {
-          result = SL20JsonExtractorUtils.getJsonObjectValue(respPayload,
-              SL20Constants.SL20_COMMAND_CONTAINER_PARAMS, false);
+          result = SL20JsonExtractorUtils.getJsonObjectValue(respPayload, SL20Constants.SL20_COMMAND_CONTAINER_PARAMS,
+              false);
         }
 
         final String errorCode = SL20JsonExtractorUtils.getStringValue(result,
@@ -166,21 +165,18 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
             SL20Constants.SL20_COMMAND_PARAM_GENERAL_RESPONSE_ERRORMESSAGE, true);
 
         log.info("Receive SL2.0 error. Code:" + errorCode + " Msg:" + errorMsg);
-        throw new SL20Exception("sl20.08", new Object[] {errorCode, errorMsg});
+        throw new SL20Exception("sl20.08", new Object[] { errorCode, errorMsg });
 
       } else {
         // TODO: update to add error handling
-        log.warn("Received an unrecognized command: "
-            + respPayload.get(SL20Constants.SL20_COMMAND_CONTAINER_NAME).asText());
-        throw new SlCommandoParserException(
-            "Received an unrecognized command: "
-                 + respPayload.get(SL20Constants.SL20_COMMAND_CONTAINER_NAME).toString());
+        log.warn(
+            "Received an unrecognized command: " + respPayload.get(SL20Constants.SL20_COMMAND_CONTAINER_NAME).asText());
+        throw new SlCommandoParserException("Received an unrecognized command: "
+            + respPayload.get(SL20Constants.SL20_COMMAND_CONTAINER_NAME).toString());
       }
 
-
     } catch (final EaafAuthenticationException e) {
-      throw new TaskExecutionException(pendingReq,
-          "SL2.0 Authentication FAILED. Msg: " + e.getMessage(), e);
+      throw new TaskExecutionException(pendingReq, "SL2.0 Authentication FAILED. Msg: " + e.getMessage(), e);
 
     } catch (final Exception e) {
       log.warn("SL2.0 Authentication FAILED with a generic error.", e);
@@ -201,18 +197,14 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
    *
    * @return signed JWT token as serialized {@link String}
    * @throws CertificateEncodingException In case of certificate parsing error
-   * @throws SL20Exception In case of a SL2.0 error
+   * @throws SL20Exception                In case of a SL2.0 error
    */
-  protected abstract String buildSignedQualifiedEidCommand()
-      throws CertificateEncodingException, SL20Exception;
+  protected abstract String buildSignedQualifiedEidCommand() throws CertificateEncodingException, SL20Exception;
 
-
-  private String extractVdaUrlForSpecificOa(final IspConfiguration oaConfig,
-      final ExecutionContext executionContext) {
+  private String extractVdaUrlForSpecificOa(final ISpConfiguration oaConfig, final ExecutionContext executionContext) {
 
     // load SP specific config for development and testing purposes
-    final String spSpecificVdaEndpoints =
-        oaConfig.getConfigurationValue(Constants.CONFIG_PROP_SP_SL20_ENDPOINT_LIST);
+    final String spSpecificVdaEndpoints = oaConfig.getConfigurationValue(Constants.CONFIG_PROP_SP_SL20_ENDPOINT_LIST);
 
     // load general configuration
     final Map<String, String> endPointMap = authConfigWithSp
@@ -220,8 +212,8 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
     endPointMap.put(Constants.CONFIG_PROP_VDA_ENDPOINT_QUALeID_DEFAULT_ELEMENT,
         authConfig.getBasicConfiguration(Constants.CONFIG_PROP_VDA_ENDPOINT_QUALeID_DEFAULT));
     if (StringUtils.isNotEmpty(spSpecificVdaEndpoints)) {
-      endPointMap.putAll(KeyValueUtils.convertListToMap(KeyValueUtils
-          .getListOfCsvValues(KeyValueUtils.normalizeCsvValueString(spSpecificVdaEndpoints))));
+      endPointMap.putAll(KeyValueUtils.convertListToMap(
+          KeyValueUtils.getListOfCsvValues(KeyValueUtils.normalizeCsvValueString(spSpecificVdaEndpoints))));
       log.debug("Find OA specific SL2.0 endpoints. Updating endPoint list ... ");
 
     }
@@ -229,8 +221,8 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
     log.trace("Find #" + endPointMap.size() + " SL2.0 endpoints ... ");
 
     // selection based on request Header
-    final String sl20VdaTypeHeader =
-        (String) executionContext.get(SL20Constants.HTTP_HEADER_SL20_VDA_TYPE.toLowerCase());
+    final String sl20VdaTypeHeader = (String) executionContext
+        .get(SL20Constants.HTTP_HEADER_SL20_VDA_TYPE.toLowerCase());
     if (StringUtils.isNotEmpty(sl20VdaTypeHeader)) {
       final String vdaUrl = endPointMap.get(sl20VdaTypeHeader);
       if (StringUtils.isNotEmpty(vdaUrl)) {
@@ -241,7 +233,6 @@ public abstract class AbstractCreateQualEidRequestTask extends AbstractAuthServl
 
     }
 
-
     log.info("NO specific VDA endpoint requested or found. Use default VDA");
     return endPointMap.get(Constants.CONFIG_PROP_VDA_ENDPOINT_QUALeID_DEFAULT_ELEMENT);
 
diff --git a/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractReceiveQualEidTask.java b/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractReceiveQualEidTask.java
index 516a33b9..87dd6263 100644
--- a/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractReceiveQualEidTask.java
+++ b/eaaf_modules/eaaf_module_auth_sl20/src/main/java/at/gv/egiz/eaaf/modules/auth/sl20/tasks/AbstractReceiveQualEidTask.java
@@ -6,9 +6,23 @@ import java.net.URISyntaxException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import at.gv.egiz.eaaf.core.api.data.EAAFConstants;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.entity.ContentType;
+import org.jose4j.base64url.Base64Url;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import at.gv.egiz.eaaf.core.api.data.EaafConstants;
 import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
 import at.gv.egiz.eaaf.core.exceptions.EaafAuthenticationException;
 import at.gv.egiz.eaaf.core.exceptions.EaafStorageException;
@@ -28,17 +42,6 @@ import at.gv.egiz.eaaf.modules.auth.sl20.utils.JsonMapper;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20Constants;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20JsonBuilderUtils;
 import at.gv.egiz.eaaf.modules.auth.sl20.utils.SL20JsonExtractorUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.http.client.utils.URIBuilder;
-import org.apache.http.entity.ContentType;
-import org.jose4j.base64url.Base64Url;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import com.fasterxml.jackson.core.JsonParseException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
 
 public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask {
   private static final Logger log = LoggerFactory.getLogger(AbstractReceiveQualEidTask.class);
@@ -81,81 +84,69 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
         }
 
         log.trace("Received SL2.0 result: " + sl20Result);
-        revisionsLogger.logEvent(pendingReq, EventCodes.AUTHPROCESS_SL20_DATAURL_IP,
-            request.getRemoteAddr());
+        revisionsLogger.logEvent(pendingReq, EventCodes.AUTHPROCESS_SL20_DATAURL_IP, request.getRemoteAddr());
 
         // parse SL2.0 command/result into JSON
         try {
-          sl20ReqObj =
-              new JsonMapper().getMapper().readTree(Base64Url.decodeToUtf8String(sl20Result));
+          sl20ReqObj = new JsonMapper().getMapper().readTree(Base64Url.decodeToUtf8String(sl20Result));
 
         } catch (final JsonParseException e) {
           log.warn("SL2.0 command or result is NOT valid JSON.", e);
           log.debug("SL2.0 msg: " + sl20Result);
-          throw new SL20Exception("sl20.02",
-              new Object[] {"SL2.0 command or result is NOT valid JSON."}, e);
+          throw new SL20Exception("sl20.02", new Object[] { "SL2.0 command or result is NOT valid JSON." }, e);
 
         }
 
         // check on errorMessage
-        final VerificationResult payLoadContainerErrorCheck =
-            SL20JsonExtractorUtils.extractSL20PayLoad(sl20ReqObj, joseTools, false);
+        final VerificationResult payLoadContainerErrorCheck = SL20JsonExtractorUtils.extractSL20PayLoad(sl20ReqObj,
+            joseTools, false);
         if (SL20JsonExtractorUtils
-            .getStringValue(payLoadContainerErrorCheck.getPayload(),
-                SL20Constants.SL20_COMMAND_CONTAINER_NAME, true)
+            .getStringValue(payLoadContainerErrorCheck.getPayload(), SL20Constants.SL20_COMMAND_CONTAINER_NAME, true)
             .equals(SL20Constants.SL20_COMMAND_IDENTIFIER_ERROR)) {
           log.debug("Find " + SL20Constants.SL20_COMMAND_IDENTIFIER_ERROR + " result .... ");
-          final JsonNode errorResult = SL20JsonExtractorUtils
-              .extractSL20Result(payLoadContainerErrorCheck.getPayload(), joseTools, false);
+          final JsonNode errorResult = SL20JsonExtractorUtils.extractSL20Result(payLoadContainerErrorCheck.getPayload(),
+              joseTools, false);
           final String errorCode = SL20JsonExtractorUtils.getStringValue(errorResult,
               SL20Constants.SL20_COMMAND_PARAM_GENERAL_RESPONSE_ERRORCODE, true);
           final String errorMsg = SL20JsonExtractorUtils.getStringValue(errorResult,
               SL20Constants.SL20_COMMAND_PARAM_GENERAL_RESPONSE_ERRORMESSAGE, false);
 
-          log.info("Receiving errorcode: {} with msg: {} from VDA! Stopping auth-process ... ",
-              errorCode, errorMsg);
+          log.info("Receiving errorcode: {} with msg: {} from VDA! Stopping auth-process ... ", errorCode, errorMsg);
           // aTrustErrorWorkAround = true;
-          throw new SL20Exception("sl20.08", new Object[] {errorCode, errorMsg});
+          throw new SL20Exception("sl20.08", new Object[] { errorCode, errorMsg });
 
         } else {
           // Receive no error - To request validation
 
           // validate reqId with inResponseTo
-          final String sl20ReqId = pendingReq.getRawData(
-              Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_REQID, String.class);
-          final String inRespTo =
-              SL20JsonExtractorUtils.getStringValue(sl20ReqObj, SL20Constants.SL20_INRESPTO, true);
+          final String sl20ReqId = pendingReq
+              .getRawData(Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_REQID, String.class);
+          final String inRespTo = SL20JsonExtractorUtils.getStringValue(sl20ReqObj, SL20Constants.SL20_INRESPTO, true);
           if (sl20ReqId == null || !sl20ReqId.equals(inRespTo)) {
-            log.info(
-                "SL20 'reqId': " + sl20ReqId + " does NOT match to 'inResponseTo':" + inRespTo);
+            log.info("SL20 'reqId': " + sl20ReqId + " does NOT match to 'inResponseTo':" + inRespTo);
             throw new SL20SecurityException(
                 "SL20 'reqId': " + sl20ReqId + " does NOT match to 'inResponseTo':" + inRespTo);
           }
 
-
           // validate signature
-          final VerificationResult payLoadContainer = SL20JsonExtractorUtils
-              .extractSL20PayLoad(sl20ReqObj, joseTools, authConfig.getBasicConfigurationBoolean(
-                  Constants.CONFIG_PROP_FORCE_EID_SIGNED_RESULT, true));
+          final VerificationResult payLoadContainer = SL20JsonExtractorUtils.extractSL20PayLoad(sl20ReqObj, joseTools,
+              authConfig.getBasicConfigurationBoolean(Constants.CONFIG_PROP_FORCE_EID_SIGNED_RESULT, true));
 
           if (payLoadContainer.isValidSigned() == null || !payLoadContainer.isValidSigned()) {
-            if (authConfig.getBasicConfigurationBoolean(
-                Constants.CONFIG_PROP_FORCE_EID_SIGNED_RESULT, true)) {
+            if (authConfig.getBasicConfigurationBoolean(Constants.CONFIG_PROP_FORCE_EID_SIGNED_RESULT, true)) {
               log.info("SL20 result from VDA was not valid signed");
-              throw new SL20SecurityException(new Object[] {"Signature on SL20 result NOT valid."});
+              throw new SL20SecurityException(new Object[] { "Signature on SL20 result NOT valid." });
 
             } else {
-              log.warn(
-                  "SL20 result from VDA is NOT valid signed, but signatures-verification "
+              log.warn("SL20 result from VDA is NOT valid signed, but signatures-verification "
                   + "is DISABLED by configuration!");
 
             }
           }
-          
+
           // extract payloaf
           final JsonNode payLoad = payLoadContainer.getPayload();
 
-
           // handle SL2.0 response payLoad
           handleResponsePayLoad(payLoad);
 
@@ -168,8 +159,7 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
         }
         pendingReq.setRawDataToTransaction(
             Constants.PENDING_REQ_STORAGE_PREFIX + SL20Constants.SL20_COMMAND_IDENTIFIER_ERROR,
-            new TaskExecutionException(pendingReq,
-                "SL2.0 Authentication FAILED. Msg: " + e.getMessage(), e));
+            new TaskExecutionException(pendingReq, "SL2.0 Authentication FAILED. Msg: " + e.getMessage(), e));
 
       } catch (final Exception e) {
         log.warn("ERROR:", e);
@@ -196,7 +186,8 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
       }
 
     } catch (final Exception e) {
-      // write internal server errror 500 according to SL2.0 specification, chapter https transport
+      // write internal server errror 500 according to SL2.0 specification, chapter
+      // https transport
       // binding
       log.warn("Can NOT build SL2.0 response. Reason: " + e.getMessage(), e);
       if (sl20Result != null) {
@@ -228,9 +219,8 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
     final ObjectNode errorCommand = SL20JsonBuilderUtils
         .createCommandResponse(SL20Constants.SL20_COMMAND_IDENTIFIER_ERROR, error, null);
 
-
-    final ObjectNode respContainer = SL20JsonBuilderUtils
-        .createGenericResponse(UUID.randomUUID().toString(), null, null, errorCommand, null);
+    final ObjectNode respContainer = SL20JsonBuilderUtils.createGenericResponse(UUID.randomUUID().toString(), null,
+        null, errorCommand, null);
 
     log.trace("SL20 response to VDA: " + respContainer);
     final StringWriter writer = new StringWriter();
@@ -247,37 +237,34 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
       final JsonNode sl20ReqObj) throws IOException, SL20Exception, URISyntaxException {
     // create response
     final Map<String, String> reqParameters = new HashMap<>();
-    reqParameters.put(EAAFConstants.PARAM_HTTP_TARGET_PENDINGREQUESTID,
-        pendingReq.getPendingRequestId());
+    reqParameters.put(EaafConstants.PARAM_HTTP_TARGET_PENDINGREQUESTID, pendingReq.getPendingRequestId());
     final ObjectNode callReqParams = SL20JsonBuilderUtils.createCallCommandParameters(
         new DataUrlBuilder().buildDataUrl(pendingReq.getAuthUrl(), getResumeEndPoint(), null),
         SL20Constants.SL20_COMMAND_PARAM_GENERAL_CALL_METHOD_GET, false, reqParameters);
-    final ObjectNode callCommand = SL20JsonBuilderUtils
-        .createCommand(SL20Constants.SL20_COMMAND_IDENTIFIER_CALL, callReqParams);
+    final ObjectNode callCommand = SL20JsonBuilderUtils.createCommand(SL20Constants.SL20_COMMAND_IDENTIFIER_CALL,
+        callReqParams);
 
     // build first redirect command for app
-    final ObjectNode redirectOneParams = SL20JsonBuilderUtils.createRedirectCommandParameters(
-        generateIpcRedirectUrlForDebugging(), callCommand, null, true);
+    final ObjectNode redirectOneParams = SL20JsonBuilderUtils
+        .createRedirectCommandParameters(generateIpcRedirectUrlForDebugging(), callCommand, null, true);
     final ObjectNode redirectOneCommand = SL20JsonBuilderUtils
         .createCommand(SL20Constants.SL20_COMMAND_IDENTIFIER_REDIRECT, redirectOneParams);
 
     // build second redirect command for IDP
-    final ObjectNode redirectTwoParams = SL20JsonBuilderUtils.createRedirectCommandParameters(
-        new DataUrlBuilder().buildDataUrl(pendingReq.getAuthUrl(), getResumeEndPoint(),
-            pendingReq.getPendingRequestId()),
+    final ObjectNode redirectTwoParams = SL20JsonBuilderUtils.createRedirectCommandParameters(new DataUrlBuilder()
+        .buildDataUrl(pendingReq.getAuthUrl(), getResumeEndPoint(), pendingReq.getPendingRequestId()),
         redirectOneCommand, null, false);
     final ObjectNode redirectTwoCommand = SL20JsonBuilderUtils
         .createCommand(SL20Constants.SL20_COMMAND_IDENTIFIER_REDIRECT, redirectTwoParams);
 
     // build generic SL2.0 response container
-    final String transactionId =
-        SL20JsonExtractorUtils.getStringValue(sl20ReqObj, SL20Constants.SL20_TRANSACTIONID, false);
-    final ObjectNode respContainer = SL20JsonBuilderUtils.createGenericRequest(
-        UUID.randomUUID().toString(), transactionId, redirectTwoCommand, null);
-
-    if (request.getHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE) != null
-        && request.getHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE)
-            .equals(SL20Constants.HTTP_HEADER_VALUE_NATIVE)) {
+    final String transactionId = SL20JsonExtractorUtils.getStringValue(sl20ReqObj, SL20Constants.SL20_TRANSACTIONID,
+        false);
+    final ObjectNode respContainer = SL20JsonBuilderUtils.createGenericRequest(UUID.randomUUID().toString(),
+        transactionId, redirectTwoCommand, null);
+
+    if (request.getHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE) != null && request
+        .getHeader(SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE).equals(SL20Constants.HTTP_HEADER_VALUE_NATIVE)) {
       log.debug("Client request containts 'native client' header ... ");
       log.trace("SL20 response to VDA: " + respContainer);
       final StringWriter writer = new StringWriter();
@@ -288,21 +275,16 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
       response.setContentType(ContentType.APPLICATION_JSON.toString());
       response.getOutputStream().write(content);
 
-
     } else {
-      log.info("SL2.0 DataURL communication needs http header: '"
-          + SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE + "'");
+      log.info("SL2.0 DataURL communication needs http header: '" + SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE + "'");
 
       log.debug("Client request containts is no native client ... ");
-      final URIBuilder clientRedirectUri =
-          new URIBuilder(new DataUrlBuilder().buildDataUrl(pendingReq.getAuthUrl(),
-              getResumeEndPoint(), pendingReq.getPendingRequestId()));
-      response.setStatus(Integer
-          .parseInt(authConfig.getBasicConfiguration(Constants.CONFIG_PROP_HTTP_REDIRECT_CODE,
-              Constants.CONFIG_PROP_HTTP_REDIRECT_CODE_DEFAULT_VALUE)));
+      final URIBuilder clientRedirectUri = new URIBuilder(new DataUrlBuilder().buildDataUrl(pendingReq.getAuthUrl(),
+          getResumeEndPoint(), pendingReq.getPendingRequestId()));
+      response.setStatus(Integer.parseInt(authConfig.getBasicConfiguration(Constants.CONFIG_PROP_HTTP_REDIRECT_CODE,
+          Constants.CONFIG_PROP_HTTP_REDIRECT_CODE_DEFAULT_VALUE)));
       response.setHeader("Location", clientRedirectUri.build().toString());
 
-
       // throw new SL20Exception("sl20.06",
       // new Object[] {"SL2.0 DataURL communication needs http header: '" +
       // SL20Constants.HTTP_HEADER_SL20_CLIENT_TYPE + "'"});
@@ -317,15 +299,12 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
    */
   private String generateIpcRedirectUrlForDebugging() {
 
-
-    String ipcRedirectUrlConfig =
-        authConfig.getBasicConfiguration(Constants.CONFIG_PROP_IPC_RETURN_URL);
+    String ipcRedirectUrlConfig = authConfig.getBasicConfiguration(Constants.CONFIG_PROP_IPC_RETURN_URL);
     if (StringUtils.isNotEmpty(ipcRedirectUrlConfig)) {
       if (ipcRedirectUrlConfig.contains(PATTERN_PENDING_REQ_ID)) {
         log.trace("Find 'pendingReqId' pattern in IPC redirect URL. Update url ... ");
         ipcRedirectUrlConfig = ipcRedirectUrlConfig.replaceAll("#PENDINGREQID#",
-            EAAFConstants.PARAM_HTTP_TARGET_PENDINGREQUESTID + "="
-                + pendingReq.getPendingRequestId());
+            EaafConstants.PARAM_HTTP_TARGET_PENDINGREQUESTID + "=" + pendingReq.getPendingRequestId());
 
       }
 
@@ -336,5 +315,4 @@ public abstract class AbstractReceiveQualEidTask extends AbstractAuthServletTask
 
   }
 
-
 }