Hotfix/v1.0.0 3

build.gradle

@@ -9,7 +9,7 @@ plugins {
 }
 
 group = 'es.in2'
-version = '1.1.1'
+version = '1.1.2'
 
 java {
 	sourceCompatibility = '17'

src/main/java/es/in2/wallet/application/service/DomeAttestationExchangeService.java

@@ -1,8 +1,11 @@
 package es.in2.wallet.application.service;
 
+import es.in2.wallet.domain.model.VcSelectorRequest;
+import es.in2.wallet.domain.model.VcSelectorResponse;
 import reactor.core.publisher.Mono;
 
 
 public interface DomeAttestationExchangeService {
-    Mono<Void> getSelectableCredentialsRequiredToBuildThePresentation(String processId, String authorizationToken, String qrContent);
+    Mono<VcSelectorRequest> getSelectableCredentialsRequiredToBuildThePresentation(String processId, String authorizationToken, String qrContent);
+    public Mono<Void> buildAndSendVerifiablePresentationWithSelectedVCsForDome(String processId, String authorizationToken, VcSelectorResponse vcSelectorResponse);
 }

src/main/java/es/in2/wallet/application/service/impl/DomeAttestationExchangeServiceImpl.java

@@ -1,31 +1,39 @@
 package es.in2.wallet.application.service.impl;
 
 import es.in2.wallet.application.service.DomeAttestationExchangeService;
+import es.in2.wallet.domain.model.VcSelectorRequest;
+import es.in2.wallet.domain.model.VcSelectorResponse;
 import es.in2.wallet.domain.service.AuthorizationRequestService;
-import es.in2.wallet.domain.service.DidKeyGeneratorService;
+import es.in2.wallet.domain.service.AuthorizationResponseService;
 import es.in2.wallet.domain.service.DomeVpTokenService;
+import es.in2.wallet.domain.service.PresentationService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
 
-import java.util.Map;
-
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class DomeAttestationExchangeServiceImpl implements DomeAttestationExchangeService {
     private final AuthorizationRequestService authorizationRequestService;
     private final DomeVpTokenService domeVpTokenService;
-    private final DidKeyGeneratorService didKeyGeneratorService;
+    private final PresentationService presentationService;
+    private final AuthorizationResponseService authorizationResponseService;
 
 
     @Override
-    public Mono<Void> getSelectableCredentialsRequiredToBuildThePresentation(String processId, String authorizationToken, String qrContent) {
+    public Mono<VcSelectorRequest> getSelectableCredentialsRequiredToBuildThePresentation(String processId, String authorizationToken, String qrContent) {
         log.info("ProcessID: {} - Processing a Verifiable Credential Login Request", processId);
         // Get Authorization Request executing the VC Login Request
         return  authorizationRequestService.getAuthorizationRequestFromAuthorizationRequestClaims(processId, qrContent)
                 // Check which Verifiable Credentials are selectable
                 .flatMap(authorizationRequest -> domeVpTokenService.getVpRequest(processId,authorizationToken,authorizationRequest));
     }
+    @Override
+    public Mono<Void> buildAndSendVerifiablePresentationWithSelectedVCsForDome(String processId, String authorizationToken, VcSelectorResponse vcSelectorResponse) {
+        // Get the Verifiable Credentials which will be used for the Presentation from the Wallet Data Service
+        return presentationService.createEncodedVerifiablePresentationForDome(processId,authorizationToken,vcSelectorResponse)
+                .flatMap(vpToken -> authorizationResponseService.sendAuthorizationResponseForDome(vpToken,vcSelectorResponse));
+    }
 }

src/main/java/es/in2/wallet/application/service/impl/UserDataUseCaseServiceImpl.java

@@ -30,7 +30,7 @@ public class UserDataUseCaseServiceImpl implements UserDataUseCaseService {
     public Mono<List<CredentialsBasicInfoWithExpirationDate>> getUserVCs(String processId, String userId) {
         return brokerService.getEntityById(processId, userId).flatMap(optionalEntity -> optionalEntity.map(userDataService::getUserVCsInJson).orElseGet(() -> {
             log.error("User with ID {} has no entity or credentials yet.", userId);
-            return Mono.error(new RuntimeException("There's no credential available."));
+            return Mono.just(List.of());
         })).doOnSuccess(list -> log.info("Retrieved VCs in JSON for userId: {}", userId)).onErrorResume(Mono::error);
     }
 

src/main/java/es/in2/wallet/domain/service/AuthorizationResponseService.java

@@ -6,4 +6,5 @@
 
 public interface AuthorizationResponseService {
     Mono<String> buildAndPostAuthorizationResponseWithVerifiablePresentation(String processId, VcSelectorResponse vcSelectorResponse, String verifiablePresentation, String authorizationToken) throws JsonProcessingException;
+    Mono<Void> sendAuthorizationResponseForDome(String vpToken, VcSelectorResponse vcSelectorResponse);
 }

src/main/java/es/in2/wallet/domain/service/DomeVpTokenService.java

@@ -1,9 +1,10 @@
 package es.in2.wallet.domain.service;
 
 import es.in2.wallet.domain.model.AuthorizationRequest;
+import es.in2.wallet.domain.model.VcSelectorRequest;
 import reactor.core.publisher.Mono;
 
 public interface DomeVpTokenService {
-    Mono<Void> getVpRequest(String processId, String authorizationToken, AuthorizationRequest authorizationRequest);
+    Mono<VcSelectorRequest> getVpRequest(String processId, String authorizationToken, AuthorizationRequest authorizationRequest);
 
 }

src/main/java/es/in2/wallet/domain/service/impl/AuthorizationResponseServiceImpl.java

@@ -21,12 +21,13 @@
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.text.ParseException;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.stream.Collectors;
 
+import static es.in2.wallet.domain.util.ApplicationUtils.postRequest;
+import static es.in2.wallet.domain.util.MessageUtils.CONTENT_TYPE;
+import static es.in2.wallet.domain.util.MessageUtils.CONTENT_TYPE_URL_ENCODED_FORM;
+
 
 @Slf4j
 @Service
@@ -43,6 +44,19 @@ public Mono<String> buildAndPostAuthorizationResponseWithVerifiablePresentation(
                 .flatMap(presentationSubmissionString -> postAuthorizationResponse(processId, vcSelectorResponse, verifiablePresentation, presentationSubmissionString, authorizationToken));
     }
 
+    @Override
+    public Mono<Void> sendAuthorizationResponseForDome(String vpToken, VcSelectorResponse vcSelectorResponse) {
+        String body = "vp_token=" + vpToken;
+        List<Map.Entry<String, String>> headers = new ArrayList<>();
+        headers.add(new AbstractMap.SimpleEntry<>(CONTENT_TYPE, CONTENT_TYPE_URL_ENCODED_FORM));
+
+        String urlWithState = vcSelectorResponse.redirectUri() + "?state=" + vcSelectorResponse.state();
+
+        return postRequest(urlWithState, headers,body)
+                .onErrorResume(e -> Mono.error(new FailedCommunicationException("Error while sending Vp Token Response")))
+                .then();
+    }
+
     private Mono<DescriptorMap> generateDescriptorMapping(String verifiablePresentationString) throws JsonProcessingException {
         // Parse the Verifiable Presentation
         return parseVerifiablePresentationFromString(verifiablePresentationString)
@@ -161,7 +175,7 @@ private Mono<String> postAuthorizationResponse(String processId, VcSelectorRespo
                                                    String verifiablePresentation, String presentationSubmissionString, String authorizationToken) {
         // Headers
         List<Map.Entry<String, String>> headers = List.of(
-                Map.entry(MessageUtils.CONTENT_TYPE, MessageUtils.CONTENT_TYPE_URL_ENCODED_FORM),
+                Map.entry(CONTENT_TYPE, CONTENT_TYPE_URL_ENCODED_FORM),
                 Map.entry(MessageUtils.HEADER_AUTHORIZATION, MessageUtils.BEARER + authorizationToken));
         // Build URL encoded form data request body
         Map<String, String> formDataMap = Map.of(
@@ -173,7 +187,7 @@ private Mono<String> postAuthorizationResponse(String processId, VcSelectorRespo
                 .map(entry -> URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8) + "=" + URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8))
                 .collect(Collectors.joining("&"));
         // Post request
-        return ApplicationUtils.postRequest(vcSelectorResponse.redirectUri(), headers, xWwwFormUrlencodedBody)
+        return postRequest(vcSelectorResponse.redirectUri(), headers, xWwwFormUrlencodedBody)
                 .doOnSuccess(response -> log.info("ProcessID: {} - Authorization Response: {}", processId, response))
                 .onErrorResume(e -> Mono.error(new FailedCommunicationException("Error while fetching Credential Issuer Metadata from the Issuer")));
     }

src/main/java/es/in2/wallet/domain/service/impl/DomeVpTokenServiceImpl.java

@@ -1,9 +1,8 @@
 package es.in2.wallet.domain.service.impl;
 
 import es.in2.wallet.application.port.BrokerService;
-import es.in2.wallet.domain.exception.FailedCommunicationException;
 import es.in2.wallet.domain.model.AuthorizationRequest;
-import es.in2.wallet.domain.model.VcSelectorResponse;
+import es.in2.wallet.domain.model.VcSelectorRequest;
 import es.in2.wallet.domain.service.DomeVpTokenService;
 import es.in2.wallet.domain.service.PresentationService;
 import es.in2.wallet.domain.service.UserDataService;
@@ -12,25 +11,16 @@
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
 
-import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
-import java.util.AbstractMap;
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 import static es.in2.wallet.domain.util.ApplicationUtils.getUserIdFromToken;
-import static es.in2.wallet.domain.util.ApplicationUtils.postRequest;
-import static es.in2.wallet.domain.util.MessageUtils.CONTENT_TYPE;
-import static es.in2.wallet.domain.util.MessageUtils.CONTENT_TYPE_URL_ENCODED_FORM;
 
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class DomeVpTokenServiceImpl implements DomeVpTokenService {
     private final UserDataService userDataService;
     private final BrokerService brokerService;
-    private final PresentationService presentationService;
 
     /**
      * Initiates the process to exchange the authorization token and JWT for a VP Token Request,
@@ -40,7 +30,7 @@ public class DomeVpTokenServiceImpl implements DomeVpTokenService {
      * @param authorizationToken The authorization token provided by the client.
      */
     @Override
-    public Mono<Void> getVpRequest(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
+    public Mono<VcSelectorRequest> getVpRequest(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
         return completeVpTokenExchange(processId, authorizationToken, authorizationRequest)
                 .doOnSuccess(tokenResponse -> log.info("ProcessID: {} - Token Response: {}", processId, tokenResponse));
     }
@@ -49,46 +39,33 @@ public Mono<Void> getVpRequest(String processId, String authorizationToken, Auth
     /**
      * Completes the VP Token exchange process by building a VP token response and extracting query parameters from it.
      */
-    private Mono<Void> completeVpTokenExchange(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
+    private Mono<VcSelectorRequest> completeVpTokenExchange(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
         return buildVpTokenResponse(processId,authorizationToken,authorizationRequest);
     }
 
-    private Mono<Void> buildVpTokenResponse(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
+    private Mono<VcSelectorRequest> buildVpTokenResponse(String processId, String authorizationToken, AuthorizationRequest authorizationRequest) {
         List<String> vcTypeList = List.of("LegalPersonCredential");
 
-        return buildBase64VerifiablePresentationByVcTypeList(processId, authorizationToken, vcTypeList)
-                .flatMap(vp -> sendVpTokenResponse(vp,authorizationRequest));
+        return buildVCSelectorRequest(processId, authorizationToken, vcTypeList,authorizationRequest);
     }
-    /**
-     * Sends the VP Token response to the redirect URI specified in the JWT, as an application/x-www-form-urlencoded payload.
-     * This includes the VP token, presentation submission, and state parameters.
-     */
-    private Mono<Void> sendVpTokenResponse(String vpToken, AuthorizationRequest authorizationRequest) {
-            String body = "vp_token=" + vpToken;
-            List<Map.Entry<String, String>> headers = new ArrayList<>();
-            headers.add(new AbstractMap.SimpleEntry<>(CONTENT_TYPE, CONTENT_TYPE_URL_ENCODED_FORM));
-
-        String urlWithState = authorizationRequest.redirectUri() + "?state=" + authorizationRequest.state();
 
-        return postRequest(urlWithState, headers,body)
-                    .onErrorResume(e -> Mono.error(new FailedCommunicationException("Error while sending Vp Token Response")))
-                    .then();
-
-    }
 
     /**
      * Builds a signed JWT Verifiable Presentation by extracting user data and credentials based on the VC type list provided.
      */
-    private Mono<String> buildBase64VerifiablePresentationByVcTypeList(String processId, String authorizationToken, List<String> vcTypeList) {
+    private Mono<VcSelectorRequest> buildVCSelectorRequest(String processId, String authorizationToken, List<String> vcTypeList, AuthorizationRequest authorizationRequest) {
         return getUserIdFromToken(authorizationToken)
                 .flatMap(userId -> brokerService.getEntityById(processId, userId))
                 .flatMap(optionalEntity -> optionalEntity
                         .map(entity ->
                                 userDataService.getSelectableVCsByVcTypeList(vcTypeList, entity)
                                         .flatMap(list -> {
                                             log.debug(list.toString());
-                                            VcSelectorResponse vcSelectorResponse = VcSelectorResponse.builder().selectedVcList(list).build();
-                                            return presentationService.createEncodedVerifiablePresentationForDome(processId, authorizationToken, vcSelectorResponse);
+                                            VcSelectorRequest vcSelectorRequest = VcSelectorRequest.builder().selectableVcList(list)
+                                                    .redirectUri(authorizationRequest.redirectUri())
+                                                    .state(authorizationRequest.state())
+                                                    .build();
+                                            return Mono.just(vcSelectorRequest);
                                         })
                         )
                         .orElseGet(() ->

src/main/java/es/in2/wallet/domain/service/impl/PresentationServiceImpl.java

@@ -104,7 +104,7 @@ private Mono<String> createVerifiablePresentationForDome(String processId, Strin
                         .map(entity -> getVerifiableCredentials(entity,selectedVcList, VC_JSON)
                                 .flatMap(this::createEncodedPresentation)
                                 // Log success
-                                .doOnSuccess(verifiablePresentation -> log.info("ProcessID: {} - Verifiable Presentation created successfully: {}", processId, verifiablePresentation))
+                                .doOnSuccess(verifiablePresentation -> log.info("ProcessID: {} - Verifiable Presentation created successfully for dome: {}", processId, verifiablePresentation))
                                 // Handle errors
                                 .onErrorResume(e -> {
                                     log.error("Error in creating Verifiable Presentation: ", e);

src/main/java/es/in2/wallet/domain/util/MessageUtils.java

@@ -58,6 +58,7 @@ private MessageUtils() {
     public static final Pattern OPENID_CREDENTIAL_OFFER_PATTERN = Pattern.compile("openid-credential-offer://\\S*");
     public static final Pattern EBSI_CREDENTIAL_OFFER_PATTERN = Pattern.compile("\\S*(conformance.ebsi)\\S*");
     public static final Pattern DOME_LOGIN_REQUEST_PATTERN = Pattern.compile("\\S*(did:web:dome-marketplace.org)\\S*");
+    public static final Pattern DOME_REDIRECT_URI_PATTERN = Pattern.compile("\\S*(dome-marketplace.org)\\S*");
     public static final Pattern OPENID_AUTHENTICATION_REQUEST_PATTERN = Pattern.compile("openid://\\S*");
 
     public static final String ISO_8601_DATE_PATTERN = "yyyy-MM-dd'T'HH:mm:ssX";

src/main/java/es/in2/wallet/infrastructure/core/controller/VerifiablePresentationController.java

@@ -1,10 +1,11 @@
 package es.in2.wallet.infrastructure.core.controller;
 
-import es.in2.wallet.infrastructure.core.config.SwaggerConfig;
 import es.in2.wallet.application.service.AttestationExchangeService;
+import es.in2.wallet.application.service.DomeAttestationExchangeService;
 import es.in2.wallet.application.service.TurnstileAttestationExchangeService;
 import es.in2.wallet.domain.model.CredentialsBasicInfo;
 import es.in2.wallet.domain.model.VcSelectorResponse;
+import es.in2.wallet.infrastructure.core.config.SwaggerConfig;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import lombok.RequiredArgsConstructor;
@@ -18,6 +19,7 @@
 import java.util.UUID;
 
 import static es.in2.wallet.domain.util.ApplicationUtils.getCleanBearerToken;
+import static es.in2.wallet.domain.util.MessageUtils.DOME_REDIRECT_URI_PATTERN;
 
 @RestController
 @RequestMapping("/api/v1/vp")
@@ -27,6 +29,7 @@ public class VerifiablePresentationController {
 
     private final TurnstileAttestationExchangeService turnstileAttestationExchangeService;
     private final AttestationExchangeService attestationExchangeService;
+    private final DomeAttestationExchangeService domeAttestationExchangeService;
     @PostMapping
     @ResponseStatus(HttpStatus.CREATED)
     @Operation(
@@ -39,8 +42,14 @@ public Mono<Void> createVerifiablePresentation(@RequestHeader(HttpHeaders.AUTHOR
         String processId = UUID.randomUUID().toString();
         MDC.put("processId", processId);
         return getCleanBearerToken(authorizationHeader)
-                .flatMap(authorizationToken ->
-                        attestationExchangeService.buildVerifiablePresentationWithSelectedVCs(processId, authorizationToken, vcSelectorResponse));
+                .flatMap(authorizationToken ->{
+                        if (DOME_REDIRECT_URI_PATTERN.matcher(vcSelectorResponse.redirectUri()).matches()){
+                            return domeAttestationExchangeService.buildAndSendVerifiablePresentationWithSelectedVCsForDome(processId,authorizationToken,vcSelectorResponse);
+                        }
+                        else {
+                            return attestationExchangeService.buildVerifiablePresentationWithSelectedVCs(processId, authorizationToken, vcSelectorResponse);
+                        }
+                }).doOnSuccess(aVoid -> log.info("Attestation exchange successful"));
     }
     @PostMapping("/cbor")
     @ResponseStatus(HttpStatus.CREATED)

src/main/resources/application.yml

@@ -76,33 +76,37 @@ hashicorp:
     host: localhost
     port: 8201
     scheme: http
-    token: "hvs.cvkSZ1qirXWnLvFyugyKbSsT"
+    token: "hvs.60TonjabQzUoOPF3HTqIPLnV"
 
-azure:
-  app:
-    endpoint: ${APP_CONFIG_ENDPOINT}
-    label:
-      global: service-discovery
-  key-vault:
-    endpoint: "your-endpoint"
+#azure:
+#  app:
+#    endpoint: ${APP_CONFIG_ENDPOINT}
+#    label:
+#      global: service-discovery
+#  key-vault:
+#    endpoint: "your-endpoint"
 
 # These properties will be removed in the future
-auth-server:
-  external-url:
-    scheme: "http"
-    domain: "localhost"
-    port: "8080"
-    path: "/cross-keycloak/realms/EAAProvider"
-  internal-url:
-    scheme: "http"
-    domain: "localhost"
-    port: "8080"
-    path: "/realms/EAAProvider"
-  token-url:
-    scheme: "http"
-    domain: "localhost"
-    port: "8080"
-    path: "/realms/EAAProvider/verifiable-credential/did:key:z6MkqmaCT2JqdUtLeKah7tEVfNXtDXtQyj4yxEgV11Y5CqUa/token"
+#auth-server:
+#  external-url:
+#    scheme: "http"
+#    domain: "localhost"
+#    port: "8080"
+#    path: "/cross-keycloak/realms/EAAProvider"
+#  internal-url:
+#    scheme: "http"
+#    domain: "localhost"
+#    port: "8080"
+#    path: "/realms/EAAProvider"
+#  token-url:
+#    scheme: "http"
+#    domain: "localhost"
+#    port: "8080"
+#    path: "/realms/EAAProvider/verifiable-credential/did:key:z6MkqmaCT2JqdUtLeKah7tEVfNXtDXtQyj4yxEgV11Y5CqUa/token"
+
+verifiable-presentation:
+  expiration-time: 3
+  expiration-unit: MINUTES #DAYS HOURS MINUTES SECONDS
 
 verifiable-presentation:
   expiration-time: 3