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/tmforum/PolicyResolver.java

package org.fiware.iam.tmforum;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.micronaut.context.annotation.Requires;
import io.micronaut.http.HttpResponse;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.configuration.GeneralProperties;
import org.fiware.iam.domain.ContractManagement;
import org.fiware.iam.tmforum.productcatalog.api.ProductOfferingApiClient;
import org.fiware.iam.tmforum.productcatalog.api.ProductSpecificationApiClient;
import org.fiware.iam.tmforum.productcatalog.model.ProductSpecificationRefVO;
import org.fiware.iam.tmforum.productcatalog.model.RelatedPartyVO;
import org.fiware.iam.tmforum.productcatalog.model.*;
import org.fiware.iam.tmforum.productorder.model.ProductOfferingRefVO;
import org.fiware.iam.tmforum.productorder.model.*;
import org.fiware.iam.tmforum.quote.api.QuoteApiClient;
import org.fiware.iam.tmforum.quote.model.QuoteItemVO;
import org.fiware.iam.tmforum.quote.model.QuoteStateTypeVO;
import org.fiware.iam.tmforum.quote.model.QuoteVO;
import reactor.core.publisher.Mono;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

/**
 * Extract policies from ProductOrders, either from the connected Quote or ProductSpec.
 */
@Requires(condition = GeneralProperties.TmForumCondition.class)
@Singleton
@Slf4j
@RequiredArgsConstructor
public class PolicyResolver {

    private static final String AUTHORIZATION_POLICY_KEY = "authorizationPolicy";
    private static final String QUOTE_DELETE_ACTION = "delete";

    private final ObjectMapper objectMapper;

    private final ProductOfferingApiClient productOfferingApiClient;
    private final ProductSpecificationApiClient productSpecificationApiClient;
    private final QuoteApiClient quoteApiClient;
    private final OrganizationResolver organizationResolver;

    public Mono<List<PolicyConfig>> getAuthorizationPolicy(ProductOrderVO productOrder) {
        if (productOrder.getQuote() != null && !productOrder.getQuote().isEmpty()) {
            return getAuthorizationPolicyFromQuote(productOrder.getQuote());
        }
        log.debug("No quote found, take the original offer from the order item.");
        List<Mono<PolicyConfig>> credentialsVOMonoList = productOrder.getProductOrderItem()
                .stream()
                .filter(poi -> poi.getAction() == OrderItemActionTypeVO.ADD || poi.getAction() == OrderItemActionTypeVO.MODIFY)
                .map(ProductOrderItemVO::getProductOffering)
                .map(ProductOfferingRefVO::getId)
                .map(this::getAuthorizationPolicyFromOffer)
                .toList();

        return zipMonoListPC(credentialsVOMonoList);
    }

    private Mono<List<PolicyConfig>> zipMonoListPC(List<Mono<PolicyConfig>> monoList) {
        return Mono.zip(monoList, results -> Stream.of(results).map(r -> (PolicyConfig) r).toList());
    }

    private Mono<List<PolicyConfig>> zipMonoList(List<Mono<List<PolicyConfig>>> monoList) {
        return Mono.zip(monoList, results -> Stream.of(results).map(r -> (List<PolicyConfig>) r).flatMap(List::stream).toList());

    }

    private Mono<PolicyConfig> getAuthorizationPolicyFromOffer(String offerId) {
        return productOfferingApiClient
                .retrieveProductOffering(offerId, null)
                .map(HttpResponse::body)
                .map(ProductOfferingVO::getProductSpecification)
                .map(ProductSpecificationRefVO::getId)
                .flatMap(specId -> productSpecificationApiClient.retrieveProductSpecification(specId, null))
                .map(HttpResponse::body)
                .flatMap(psvo -> {
                    List<Map<String, Object>> policies = getAuthorizationPolicyFromPSC(psvo.getProductSpecCharacteristic());
                    Optional<String> partyId = Optional.ofNullable(psvo.getRelatedParty())
                            .orElse(List.of())
                            .stream()
                            .filter(relatedPartyVO -> organizationResolver.hasProviderRole(relatedPartyVO.getRole()))
                            .map(RelatedPartyVO::getId)
                            .findAny();
                    return partyId.map(string -> organizationResolver.getContractManagement(string)
                                    .map(cm -> new PolicyConfig(cm, policies)))
                            .orElseGet(() -> Mono.just(new PolicyConfig(new ContractManagement(true), policies)));
                });
    }

    private Mono<List<PolicyConfig>> getAuthorizationPolicyFromQuote(List<QuoteRefVO> quoteRefVOS) {
        return zipMonoList(quoteRefVOS.stream()
                .map(QuoteRefVO::getId)
                .map(quoteId -> quoteApiClient.retrieveQuote(quoteId, null)
                        .map(HttpResponse::body)
                        .filter(quoteVO -> quoteVO.getState() == QuoteStateTypeVO.ACCEPTED)
                        .map(QuoteVO::getQuoteItem)
                        .flatMap(quoteItemList -> {
                            List<Mono<PolicyConfig>> configMonos = quoteItemList.stream()
                                    .filter(item -> item.getState().equals(QuoteStateTypeVO.ACCEPTED.getValue()))
                                    .filter(item -> !item.getAction().equals(QUOTE_DELETE_ACTION))
                                    .map(QuoteItemVO::getProductOffering)
                                    .map(org.fiware.iam.tmforum.quote.model.ProductOfferingRefVO::getId)
                                    .map(this::getAuthorizationPolicyFromOffer)
                                    .toList();
                            return zipMonoListPC(configMonos);
                        }))
                .toList());
    }

    private List<Map<String, Object>> getAuthorizationPolicyFromPSC(List<ProductSpecificationCharacteristicVO> pscList) {
        return pscList.stream()
                .filter(psc -> psc.getValueType().equals(AUTHORIZATION_POLICY_KEY))
                .findFirst()
                .map(productSpecificationCharacteristicVO -> productSpecificationCharacteristicVO
                        .getProductSpecCharacteristicValue()
                        .stream()
                        .map(CharacteristicValueSpecificationVO::getValue)
                        .map(value -> {
                            try {
                                List<Map<String, Object>> policies = objectMapper.convertValue(value, new TypeReference<List<Map<String, Object>>>() {
                                });
                                log.debug("Policy is {}", policies);
                                return policies;
                            } catch (IllegalArgumentException iae) {
                                log.warn("The characteristic value is invalid.", iae);
                                return null;
                            }
                        })
                        .filter(Objects::nonNull)
                        .flatMap(List::stream)
                        .toList()).orElseGet(List::of);
    }

    public record PolicyConfig(ContractManagement contractManagement, List<Map<String, Object>> policies) {
    }
}

1	package org.fiware.iam.tmforum;
2
3	import com.fasterxml.jackson.core.type.TypeReference;
4	import com.fasterxml.jackson.databind.ObjectMapper;
5	import io.micronaut.context.annotation.Requires;
6	import io.micronaut.http.HttpResponse;
7	import jakarta.inject.Singleton;
8	import lombok.RequiredArgsConstructor;
9	import lombok.extern.slf4j.Slf4j;
10	import org.fiware.iam.configuration.GeneralProperties;
11	import org.fiware.iam.domain.ContractManagement;
12	import org.fiware.iam.tmforum.productcatalog.api.ProductOfferingApiClient;
13	import org.fiware.iam.tmforum.productcatalog.api.ProductSpecificationApiClient;
14	import org.fiware.iam.tmforum.productcatalog.model.ProductSpecificationRefVO;
15	import org.fiware.iam.tmforum.productcatalog.model.RelatedPartyVO;
16	import org.fiware.iam.tmforum.productcatalog.model.*;
17	import org.fiware.iam.tmforum.productorder.model.ProductOfferingRefVO;
18	import org.fiware.iam.tmforum.productorder.model.*;
19	import org.fiware.iam.tmforum.quote.api.QuoteApiClient;
20	import org.fiware.iam.tmforum.quote.model.QuoteItemVO;
21	import org.fiware.iam.tmforum.quote.model.QuoteStateTypeVO;
22	import org.fiware.iam.tmforum.quote.model.QuoteVO;
23	import reactor.core.publisher.Mono;
24
25	import java.util.List;
26	import java.util.Map;
27	import java.util.Objects;
28	import java.util.Optional;
29	import java.util.stream.Stream;
30
31	/**
32	* Extract policies from ProductOrders, either from the connected Quote or ProductSpec.
33	*/
34	@Requires(condition = GeneralProperties.TmForumCondition.class)
35	@Singleton
36	@Slf4j	×
37	@RequiredArgsConstructor
38	public class PolicyResolver {
39
40	private static final String AUTHORIZATION_POLICY_KEY = "authorizationPolicy";
41	private static final String QUOTE_DELETE_ACTION = "delete";
42
43	private final ObjectMapper objectMapper;
44
45	private final ProductOfferingApiClient productOfferingApiClient;
46	private final ProductSpecificationApiClient productSpecificationApiClient;
47	private final QuoteApiClient quoteApiClient;
48	private final OrganizationResolver organizationResolver;
49
50	public Mono<List<PolicyConfig>> getAuthorizationPolicy(ProductOrderVO productOrder) {
51	if (productOrder.getQuote() != null && !productOrder.getQuote().isEmpty()) {	×
52	return getAuthorizationPolicyFromQuote(productOrder.getQuote());	×
53	}
54	log.debug("No quote found, take the original offer from the order item.");	×
55	List<Mono<PolicyConfig>> credentialsVOMonoList = productOrder.getProductOrderItem()	×
56	.stream()	×
57	.filter(poi -> poi.getAction() == OrderItemActionTypeVO.ADD \|\| poi.getAction() == OrderItemActionTypeVO.MODIFY)	×
58	.map(ProductOrderItemVO::getProductOffering)	×
59	.map(ProductOfferingRefVO::getId)	×
60	.map(this::getAuthorizationPolicyFromOffer)	×
61	.toList();	×
62
63	return zipMonoListPC(credentialsVOMonoList);	×
64	}
65
66	private Mono<List<PolicyConfig>> zipMonoListPC(List<Mono<PolicyConfig>> monoList) {
67	return Mono.zip(monoList, results -> Stream.of(results).map(r -> (PolicyConfig) r).toList());	×
68	}
69
70	private Mono<List<PolicyConfig>> zipMonoList(List<Mono<List<PolicyConfig>>> monoList) {
71	return Mono.zip(monoList, results -> Stream.of(results).map(r -> (List<PolicyConfig>) r).flatMap(List::stream).toList());	×
72
73	}
74
75	private Mono<PolicyConfig> getAuthorizationPolicyFromOffer(String offerId) {
76	return productOfferingApiClient	×
77	.retrieveProductOffering(offerId, null)	×
78	.map(HttpResponse::body)	×
79	.map(ProductOfferingVO::getProductSpecification)	×
80	.map(ProductSpecificationRefVO::getId)	×
81	.flatMap(specId -> productSpecificationApiClient.retrieveProductSpecification(specId, null))	×
82	.map(HttpResponse::body)	×
83	.flatMap(psvo -> {	×
84	List<Map<String, Object>> policies = getAuthorizationPolicyFromPSC(psvo.getProductSpecCharacteristic());	×
85	Optional<String> partyId = Optional.ofNullable(psvo.getRelatedParty())	×
86	.orElse(List.of())	×
87	.stream()	×
NEW 88	.filter(relatedPartyVO -> organizationResolver.hasProviderRole(relatedPartyVO.getRole()))	×
89	.map(RelatedPartyVO::getId)	×
90	.findAny();	×
91	return partyId.map(string -> organizationResolver.getContractManagement(string)	×
92	.map(cm -> new PolicyConfig(cm, policies)))	×
93	.orElseGet(() -> Mono.just(new PolicyConfig(new ContractManagement(true), policies)));	×
94	});
95	}
96
97	private Mono<List<PolicyConfig>> getAuthorizationPolicyFromQuote(List<QuoteRefVO> quoteRefVOS) {
98	return zipMonoList(quoteRefVOS.stream()	×
99	.map(QuoteRefVO::getId)	×
100	.map(quoteId -> quoteApiClient.retrieveQuote(quoteId, null)	×
101	.map(HttpResponse::body)	×
102	.filter(quoteVO -> quoteVO.getState() == QuoteStateTypeVO.ACCEPTED)	×
103	.map(QuoteVO::getQuoteItem)	×
104	.flatMap(quoteItemList -> {	×
105	List<Mono<PolicyConfig>> configMonos = quoteItemList.stream()	×
106	.filter(item -> item.getState().equals(QuoteStateTypeVO.ACCEPTED.getValue()))	×
107	.filter(item -> !item.getAction().equals(QUOTE_DELETE_ACTION))	×
108	.map(QuoteItemVO::getProductOffering)	×
109	.map(org.fiware.iam.tmforum.quote.model.ProductOfferingRefVO::getId)	×
110	.map(this::getAuthorizationPolicyFromOffer)	×
111	.toList();	×
112	return zipMonoListPC(configMonos);	×
113	}))
114	.toList());	×
115	}
116
117	private List<Map<String, Object>> getAuthorizationPolicyFromPSC(List<ProductSpecificationCharacteristicVO> pscList) {
118	return pscList.stream()	×
119	.filter(psc -> psc.getValueType().equals(AUTHORIZATION_POLICY_KEY))	×
120	.findFirst()	×
121	.map(productSpecificationCharacteristicVO -> productSpecificationCharacteristicVO	×
122	.getProductSpecCharacteristicValue()	×
123	.stream()	×
124	.map(CharacteristicValueSpecificationVO::getValue)	×
125	.map(value -> {	×
126	try {
127	List<Map<String, Object>> policies = objectMapper.convertValue(value, new TypeReference<List<Map<String, Object>>>() {	×
128	});
129	log.debug("Policy is {}", policies);	×
130	return policies;	×
131	} catch (IllegalArgumentException iae) {	×
132	log.warn("The characteristic value is invalid.", iae);	×
133	return null;	×
134	}
135	})
136	.filter(Objects::nonNull)	×
137	.flatMap(List::stream)	×
138	.toList()).orElseGet(List::of);	×
139	}
140
141	public record PolicyConfig(ContractManagement contractManagement, List<Map<String, Object>> policies) {	×
142	}
143	}

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