Hotfix/v1.0.0 3

src/main/java/es/in2/wallet/domain/model/CredentialsBasicInfoWithExpirationDate.java

@@ -14,6 +14,7 @@
 public record CredentialsBasicInfoWithExpirationDate(
         @JsonProperty("id") String id,
         @JsonProperty("type") List<String> vcType,
+        @JsonProperty(AVAILABLE_FORMATS) List<String> availableFormats,
         @JsonProperty(CREDENTIAL_SUBJECT) JsonNode credentialSubject,
         @JsonProperty(EXPIRATION_DATE)
         @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = ISO_8601_DATE_PATTERN)

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

@@ -51,9 +51,15 @@ public Mono<Void> sendDomeAuthorizationResponse(String vpToken, VcSelectorRespon
 
         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();
+        return postRequest(urlWithState, headers,body).flatMap(message ->
+                {
+                    if (!message.equals("{}")){
+                        return  Mono.error(new RuntimeException("There was an error during the attestation exchange, error: " + message));
+                    }
+                    else {
+                        return Mono.empty();
+                    }
+                }).then();
     }
 
     private Mono<DescriptorMap> generateDescriptorMapping(String verifiablePresentationString) throws JsonProcessingException {

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

@@ -239,17 +239,33 @@ public Mono<List<CredentialsBasicInfoWithExpirationDate>> getUserVCsInJson(Strin
                     LinkedHashMap<?, ?> vcDataValue = (LinkedHashMap<?, ?>) item.value();
                     JsonNode jsonNode = objectMapper.convertValue(vcDataValue, JsonNode.class);
 
-                    return getVcTypeListFromVcJson(jsonNode)
-                            .map(vcTypeList -> {
-                                ZonedDateTime expirationDate = null;
-                                if (jsonNode.has(EXPIRATION_DATE) && !jsonNode.get(EXPIRATION_DATE).isNull()) {
-                                    expirationDate = parseZonedDateTime(jsonNode.get(EXPIRATION_DATE).asText());
-                                }
-                                return new CredentialsBasicInfoWithExpirationDate(item.id(), vcTypeList, jsonNode.get(CREDENTIAL_SUBJECT), expirationDate);
-                            });
+                    Mono<List<String>> availableFormatsMono = getAvailableFormatListById(item.id(), userEntity);
+
+                    return Mono.zip(
+                            getVcTypeListFromVcJson(jsonNode),
+                            availableFormatsMono,
+                            Mono.just(jsonNode)
+                    ).flatMap(tuple -> {
+                        List<String> vcTypeList = tuple.getT1();
+                        List<String> availableFormats = tuple.getT2();
+                        JsonNode credentialSubject = tuple.getT3().get(CREDENTIAL_SUBJECT);
+
+                        ZonedDateTime expirationDate = null;
+                        if (jsonNode.has(EXPIRATION_DATE) && !jsonNode.get(EXPIRATION_DATE).isNull()) {
+                            expirationDate = parseZonedDateTime(jsonNode.get(EXPIRATION_DATE).asText());
+                        }
+                        return Mono.just(new CredentialsBasicInfoWithExpirationDate(
+                                item.id(),
+                                vcTypeList,
+                                availableFormats,
+                                credentialSubject,
+                                expirationDate
+                        ));
+                    });
                 }).collectList().onErrorResume(NoSuchVerifiableCredentialException.class, Mono::error);
     }
 
+
     /**
      * This method parses a date-time string into a ZonedDateTime object using a custom DateTimeFormatter.
      * The formatter is built with Locale.US to ensure consistency in parsing text-based elements of the date-time,
@@ -428,6 +444,20 @@ private Mono<List<String>> getVcTypeListFromVcJson(JsonNode jsonNode) {
         }
     }
 
+    /**
+     * Extracts a list of VC available format from a VC id.
+     *
+     * @param credentialId The id of the VC.
+     */
+    private Mono<List<String>> getAvailableFormatListById(String credentialId,String userEntity) {
+        return serializeUserEntity(userEntity).flatMap(user -> {
+            List<VCAttribute> vcAttributeList = user.vcs().value().stream().filter(vc -> vc.id().equals(credentialId)&& !vc.type().equals(VC_JSON)).toList();
+            List<String> availableFormats = new ArrayList<>();
+            vcAttributeList.forEach(cred -> availableFormats.add(cred.type()));
+            return Mono.just(availableFormats);
+        });
+    }
+
     /**
      * Retrieves a specific Verifiable Credential by its ID and format for a user entity.
      *

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

@@ -52,6 +52,7 @@ private MessageUtils() {
     public static final String JWT_VC = "jwt_vc";
     public static final String JWT_VC_JSON = "jwt_vc_json";
     public static final String JWT_VP = "jwt_vp";
+    public static final String AVAILABLE_FORMATS = "available_formats";
     public static final String ALLOWED_METHODS = "*";
     public static final String GLOBAL_ENDPOINTS_API = "/api/v1/**";
     public static final Pattern LOGIN_REQUEST_PATTERN = Pattern.compile("(https|http)\\S*(authentication-request|authentication-requests)\\S*");
@@ -63,6 +64,6 @@ private MessageUtils() {
     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";
-    public static final List<String> DEFAULT_VC_TYPES_FOR_DOME_VERIFIER = List.of("LegalPersonCredential", "LEARCredentialEmployee");
+    public static final List<String> DEFAULT_VC_TYPES_FOR_DOME_VERIFIER = List.of("LegalPersonCredential","LEARCredentialEmployee");
     public static final List<String> DEFAULT_SCOPE_FOR_DOME_VERIFIER = List.of("didRead", "defaultScope");
 }

src/main/java/es/in2/wallet/infrastructure/ebsi/config/EbsiConfig.java

@@ -53,18 +53,32 @@ private Mono<String> generateEbsiDid() {
         log.debug(headers.toString());
 
         headers.add(new AbstractMap.SimpleEntry<>(CONTENT_TYPE, CONTENT_TYPE_URL_ENCODED_FORM));
-        String clientSecret;
+
+        String clientSecret = appConfig.getIdentityProviderClientSecret().trim();
+        String decodedSecret;
+
         try {
-            byte[] decodedBytes = Base64.getDecoder().decode(appConfig.getIdentityProviderClientSecret());
-            clientSecret = new String(decodedBytes).trim();
+            // Attempt to decode the clientSecret assuming it is Base64 encoded.
+            byte[] decodedBytes = Base64.getDecoder().decode(clientSecret);
+            decodedSecret = new String(decodedBytes, StandardCharsets.UTF_8);
+
+            // Check if re-encoding the decoded result gives us the original string.
+            String reEncodedSecret = Base64.getEncoder().encodeToString(decodedSecret.getBytes(StandardCharsets.UTF_8)).trim();
+            if (!clientSecret.equals(reEncodedSecret)) {
+                // If re-encoding the decoded text does not match the original string,
+                // assume the original was not in Base64 and use it as it was.
+                decodedSecret = clientSecret;
+            }
         } catch (IllegalArgumentException ex) {
-           clientSecret = appConfig.getIdentityProviderClientSecret().trim();
+            // If an error occurs during decoding, assume the string was not in Base64.
+            decodedSecret = clientSecret;
         }
+
         String body = "grant_type=" + URLEncoder.encode("password", StandardCharsets.UTF_8) +
                 "&username=" + URLEncoder.encode(appConfig.getIdentityProviderUsername(), StandardCharsets.UTF_8) +
                 "&password=" + URLEncoder.encode(appConfig.getIdentityProviderPassword(), StandardCharsets.UTF_8) +
                 "&client_id=" + URLEncoder.encode(appConfig.getIdentityProviderClientId(), StandardCharsets.UTF_8) +
-                "&client_secret=" + URLEncoder.encode(clientSecret, StandardCharsets.UTF_8);
+                "&client_secret=" + URLEncoder.encode(decodedSecret, StandardCharsets.UTF_8);
 
         return Mono.delay(Duration.ofSeconds(30))
                 .then(postRequest(appConfig.getIdentityProviderUrl(), headers, body))

src/test/java/es/in2/wallet/api/facade/UserDataUseCaseServiceImplTest.java

@@ -46,11 +46,11 @@ void getUserVCs_UserExists_ReturnsVCs() throws JsonProcessingException {
         Optional<String> userEntity = Optional.of(userEntityString);
 
 
-        String json = "{\"id\":\"subjectId\"}";
+        String jsonSubject = "{\"id\":\"subjectId\"}";
         ObjectMapper objectMapper2 = new ObjectMapper();
-        JsonNode credentialSubject = objectMapper2.readTree(json);
+        JsonNode credentialSubject = objectMapper2.readTree(jsonSubject);
 
-        List<CredentialsBasicInfoWithExpirationDate> expectedCredentials = List.of(new CredentialsBasicInfoWithExpirationDate("id1", List.of("type"), credentialSubject, ZonedDateTime.now()));
+        List<CredentialsBasicInfoWithExpirationDate> expectedCredentials = List.of(new CredentialsBasicInfoWithExpirationDate("id1", List.of("type"), List.of("jwt_vc","cwt_vc"),credentialSubject, ZonedDateTime.now()));
 
         when(brokerService.getEntityById(processId, userId)).thenReturn(Mono.just(userEntity));
         when(userDataService.getUserVCsInJson(anyString())).thenReturn(Mono.just(expectedCredentials));

src/test/java/es/in2/wallet/api/service/AuthorizationResponseServiceImplTest.java

@@ -124,15 +124,15 @@ void sendDomeAuthorizationResponse_Success() {
                     .state("abc123")
                     .build();
 
-            when(postRequest(anyString(), anyList(), anyString())).thenReturn(Mono.just("Success"));
+            when(postRequest(anyString(), anyList(), anyString())).thenReturn(Mono.just("{}"));
 
             StepVerifier.create(authorizationResponseService.sendDomeAuthorizationResponse(vpToken, vcSelectorResponse))
                     .verifyComplete();
         }
     }
 
     @Test
-    void sendDomeAuthorizationResponse_ErrorHandling() {
+    void sendDomeAuthorizationResponse_RuntimeExceptionError() {
         try (MockedStatic<ApplicationUtils> ignored = Mockito.mockStatic(ApplicationUtils.class)) {
             String vpToken = "vpToken123";
             VcSelectorResponse vcSelectorResponse = VcSelectorResponse.builder()
@@ -144,8 +144,31 @@ void sendDomeAuthorizationResponse_ErrorHandling() {
             when(postRequest(anyString(), anyList(), anyString())).thenReturn(Mono.error(new RuntimeException("Network error")));
 
             StepVerifier.create(authorizationResponseService.sendDomeAuthorizationResponse(vpToken, vcSelectorResponse))
-                    .expectErrorMatches(throwable -> throwable instanceof FailedCommunicationException &&
-                            throwable.getMessage().contains("Error while sending Vp Token Response"))
+                    .expectError(RuntimeException.class)
+                    .verify();
+        }
+    }
+
+    @Test
+    void sendDomeAuthorizationResponse_ErrorHandling() {
+        try (MockedStatic<ApplicationUtils> ignored = Mockito.mockStatic(ApplicationUtils.class)) {
+            String vpToken = "vpToken123";
+            VcSelectorResponse vcSelectorResponse = VcSelectorResponse.builder()
+                    .redirectUri("https://example.com/redirect")
+                    .state("abc123")
+                    .build();
+            String errorMessage = """
+                    {
+                        "summary": "invalid_vc"
+                    }
+                    """;
+
+            // Simula un error durante el envío de la respuesta
+            when(postRequest(anyString(), anyList(), anyString())).thenReturn(Mono.just(errorMessage));
+
+            StepVerifier.create(authorizationResponseService.sendDomeAuthorizationResponse(vpToken, vcSelectorResponse))
+                    .expectErrorMatches(throwable -> throwable instanceof RuntimeException &&
+                            throwable.getMessage().contains("There was an error during the attestation exchange, error: " + errorMessage))
                     .verify();
         }
     }

src/test/java/es/in2/wallet/api/service/DomeVpTokenServiceImplTest.java

@@ -76,5 +76,45 @@ void getVpRequestShouldReturnVcSelectorRequest() {
             verify(brokerService).getEntityById(processId, userId);
     }
     }
+    @Test
+    void getVpRequestShouldReturnVcSelectorRequestWithDomeScope() {
+        try (MockedStatic<ApplicationUtils> ignored = Mockito.mockStatic(ApplicationUtils.class)){
+            String processId = "processId";
+            String authorizationToken = "authToken";
+            AuthorizationRequest authorizationRequest = mock(AuthorizationRequest.class);
+            when(authorizationRequest.scope()).thenReturn(Arrays.asList("didRead", "defaultScope"));
+            when(authorizationRequest.redirectUri()).thenReturn("https://redirectUri.com");
+            when(authorizationRequest.state()).thenReturn("state123");
+
+            String userId = "userId";
+            when(getUserIdFromToken(authorizationToken)).thenReturn(Mono.just(userId));
+
+            String userEntity = "userEntityId";
+            when(brokerService.getEntityById(processId, userId)).thenReturn(Mono.just(Optional.of(userEntity)));
+
+            // Ajusta aquí para usar CredentialsBasicInfo
+            List<CredentialsBasicInfo> selectableVCs = List.of(
+                    new CredentialsBasicInfo("vcId1", List.of("vcType1"), JsonNodeFactory.instance.objectNode().put("example", "data"))
+            );
+            when(userDataService.getSelectableVCsByVcTypeList(anyList(), eq(userEntity))).thenReturn(Mono.just(selectableVCs));
+
+            VcSelectorRequest expectedVcSelectorRequest = VcSelectorRequest.builder()
+                    .selectableVcList(selectableVCs)
+                    .redirectUri("https://redirectUri.com")
+                    .state("state123")
+                    .build();
+
+            StepVerifier.create(domeVpTokenService.getVpRequest(processId, authorizationToken, authorizationRequest))
+                    .expectNextMatches(vcSelectorRequest ->
+                            vcSelectorRequest.selectableVcList().equals(expectedVcSelectorRequest.selectableVcList()) &&
+                                    vcSelectorRequest.redirectUri().equals(expectedVcSelectorRequest.redirectUri()) &&
+                                    vcSelectorRequest.state().equals(expectedVcSelectorRequest.state())
+                    )
+                    .verifyComplete();
+
+            verify(userDataService).getSelectableVCsByVcTypeList(anyList(), eq(userEntity));
+            verify(brokerService).getEntityById(processId, userId);
+        }
+    }
 }
 

src/test/java/es/in2/wallet/api/service/PreAuthorizedServiceImplTest.java

@@ -117,5 +117,32 @@ void getPreAuthorizedTokenWithPinTest() throws JsonProcessingException {
                     .verifyComplete();
         }
     }
+    @Test
+    void getPreAuthorizedTokenWithPinInvalidPinException () throws JsonProcessingException {
+        try (MockedStatic<ApplicationUtils> ignored = Mockito.mockStatic(ApplicationUtils.class)) {
+            String processId = "123";
+            String token = "ey123";
+            String userId = "user123";
+            String userPin = "1234";
+            String tokenResponseString = "token response";
+            CredentialOffer.Grant.PreAuthorizedCodeGrant preAuthorizedCodeGrant = CredentialOffer.Grant.PreAuthorizedCodeGrant.builder()
+                    .preAuthorizedCode("321").userPinRequired(true).build();
+            CredentialOffer.Grant grant = CredentialOffer.Grant.builder().preAuthorizedCodeGrant(preAuthorizedCodeGrant).build();
+            CredentialOffer credentialOffer = CredentialOffer.builder().grant(grant).build();
+            AuthorisationServerMetadata authorisationServerMetadata = AuthorisationServerMetadata.builder().tokenEndpoint("/token").build();
+            List<Map.Entry<String, String>> headers = List.of(Map.entry(CONTENT_TYPE, CONTENT_TYPE_URL_ENCODED_FORM));
+
+            when(getUserIdFromToken(token)).thenReturn(Mono.just(userId));
+            when(sessionManager.getSession(userId)).thenReturn(Mono.just(mockSession));
+            when(pinRequestWebSocketHandler.getPinResponses(userId)).thenReturn(Flux.just(userPin));
+            when(postRequest(eq(authorisationServerMetadata.tokenEndpoint()), eq(headers), anyString()))
+                    .thenReturn(Mono.just(tokenResponseString));
+            when(objectMapper.readValue(tokenResponseString, TokenResponse.class)).thenThrow(new RuntimeException());
+
+            StepVerifier.create(tokenService.getPreAuthorizedToken(processId,credentialOffer,authorisationServerMetadata,token))
+                    .expectError(InvalidPinException.class)
+                    .verify();
+        }
+    }
 
 }