FIWARE / contract-management / #91

Committed 22 Apr 2026 06:29AM UTC coverage: 1.776% (+0.1%) from 1.681%

Build # #91

Build Type

push

Committed by

Commit Message

Merge pull request #23 from FIWARE/fix/proxy

fix(proxy): do not require proxyHost and proxyPort when proxy is disabled

Coverage Stats

20 of 136 new or added lines in 11 files covered. (14.71%)

1 existing line in 1 file now uncovered.

621 of 34976 relevant lines covered (1.78%)

0.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/fiware/iam/http/Oid4VpAuthHandler.java

package org.fiware.iam.http;

import io.github.wistefan.oid4vp.OID4VPClient;
import io.github.wistefan.oid4vp.config.RequestParameters;
import io.github.wistefan.oid4vp.exception.BadGatewayException;
import io.github.wistefan.oid4vp.model.TokenResponse;
import io.micronaut.context.annotation.Requires;
import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.MutableHttpRequest;
import io.micronaut.http.client.exceptions.HttpClientResponseException;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.configuration.Oid4VpConfiguration;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;


@Requires(condition = Oid4VpConfiguration.Oid4VpCondition.class)
@Slf4j
@Singleton
@RequiredArgsConstructor
public class Oid4VpAuthHandler implements AuthHandler {

    public static final String CLIENT_ID_ATTRIBUTE = "clientId";
    public static final String SCOPE_ATTRIBUTE = "scope";

    private final OID4VPClient oid4VPClient;

    private Set<String> getScope(HttpRequest request) {
        return request.getAttribute(SCOPE_ATTRIBUTE, Set.class)
                .map(set -> (Set<?>) set) // Optional<Set<?>>
                .orElse(Set.of())
                .stream()
                .filter(String.class::isInstance)
                .map(String.class::cast)
                .collect(Collectors.toSet());
    }

    private String getClientId(HttpRequest request) {
        return request.getAttribute(CLIENT_ID_ATTRIBUTE)
                .filter(String.class::isInstance)
                .map(String.class::cast)
                .orElse("");
    }

    @Override
    public Mono<HttpResponse> executeWithAuth(MutableHttpRequest<?> request, Function<MutableHttpRequest<?>, Mono<HttpResponse>> executor) {
        return executor.apply(request)
                .onErrorResume(t -> {
                    if (t instanceof HttpClientResponseException hcre) {
                        return Mono.just(hcre.getResponse());
                    } else {
                        throw new BadGatewayException("Was not able to call downstream service.", t);
                    }
                })
                .flatMap(response -> {
                    if (response.getStatus() == HttpStatus.UNAUTHORIZED) {
                        int port = request.getUri().getPort();
                        String portSuffix = port < 0 ? "" : ":" + port;
                        RequestParameters params = new RequestParameters(
                                URI.create(request.getUri().getScheme() + "://" + request.getUri().getHost() + portSuffix),
                                request.getPath(),
                                getClientId(request),
                                getScope(request)
                        );
                        return Mono.fromFuture(oid4VPClient.getAccessToken(params))
                                .map(TokenResponse::getAccessToken)
                                .flatMap(token -> {
                                    request.bearerAuth(token);
                                    return executor.apply(request);
                                });
                    }
                    return Mono.just(response);
                });
    }
}

1	package org.fiware.iam.http;
2
3	import io.github.wistefan.oid4vp.OID4VPClient;
4	import io.github.wistefan.oid4vp.config.RequestParameters;
5	import io.github.wistefan.oid4vp.exception.BadGatewayException;
6	import io.github.wistefan.oid4vp.model.TokenResponse;
7	import io.micronaut.context.annotation.Requires;
8	import io.micronaut.http.HttpRequest;
9	import io.micronaut.http.HttpResponse;
10	import io.micronaut.http.HttpStatus;
11	import io.micronaut.http.MutableHttpRequest;
12	import io.micronaut.http.client.exceptions.HttpClientResponseException;
13	import jakarta.inject.Singleton;
14	import lombok.RequiredArgsConstructor;
15	import lombok.extern.slf4j.Slf4j;
16	import org.fiware.iam.configuration.Oid4VpConfiguration;
17	import reactor.core.publisher.Mono;
18
19	import java.net.URI;
20	import java.util.Set;
21	import java.util.function.Function;
22	import java.util.stream.Collectors;
23
24
25	@Requires(condition = Oid4VpConfiguration.Oid4VpCondition.class)
26	@Slf4j	×
27	@Singleton
28	@RequiredArgsConstructor
29	public class Oid4VpAuthHandler implements AuthHandler {
30
31	public static final String CLIENT_ID_ATTRIBUTE = "clientId";
32	public static final String SCOPE_ATTRIBUTE = "scope";
33
34	private final OID4VPClient oid4VPClient;
35
36	private Set<String> getScope(HttpRequest request) {
37	return request.getAttribute(SCOPE_ATTRIBUTE, Set.class)	×
38	.map(set -> (Set<?>) set) // Optional<Set<?>>	×
39	.orElse(Set.of())	×
40	.stream()	×
41	.filter(String.class::isInstance)	×
42	.map(String.class::cast)	×
43	.collect(Collectors.toSet());	×
44	}
45
46	private String getClientId(HttpRequest request) {
47	return request.getAttribute(CLIENT_ID_ATTRIBUTE)	×
48	.filter(String.class::isInstance)	×
49	.map(String.class::cast)	×
50	.orElse("");	×
51	}
52
53	@Override
54	public Mono<HttpResponse> executeWithAuth(MutableHttpRequest<?> request, Function<MutableHttpRequest<?>, Mono<HttpResponse>> executor) {
55	return executor.apply(request)	×
56	.onErrorResume(t -> {	×
57	if (t instanceof HttpClientResponseException hcre) {	×
58	return Mono.just(hcre.getResponse());	×
59	} else {
60	throw new BadGatewayException("Was not able to call downstream service.", t);	×
61	}
62	})
63	.flatMap(response -> {	×
64	if (response.getStatus() == HttpStatus.UNAUTHORIZED) {	×
NEW 65	int port = request.getUri().getPort();	×
NEW 66	String portSuffix = port < 0 ? "" : ":" + port;	×
67	RequestParameters params = new RequestParameters(	×
NEW 68	URI.create(request.getUri().getScheme() + "://" + request.getUri().getHost() + portSuffix),	×
69	request.getPath(),	×
70	getClientId(request),	×
71	getScope(request)	×
72	);
73	return Mono.fromFuture(oid4VPClient.getAccessToken(params))	×
74	.map(TokenResponse::getAccessToken)	×
75	.flatMap(token -> {	×
76	request.bearerAuth(token);	×
77	return executor.apply(request);	×
78	});
79	}
80	return Mono.just(response);	×
81	});
82	}
83	}

FIWARE / contract-management / #91

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous