FIWARE / contract-management / #58

Committed 19 Aug 2025 07:56AM UTC coverage: 1.654% (-0.07%) from 1.725%

Build # #58

Build Type

push

Committed by

Commit Message

Merge pull request #10 from FIWARE/policy-support

Policy support

Run Details

2 of 67 new or added lines in 4 files covered. (2.99%)

25 existing lines in 3 files now uncovered.

559 of 33806 relevant lines covered (1.65%)

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.http.HttpResponse;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.til.model.CredentialsVO;
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.*;
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.stream.Stream;

/**
 * Extract policies from ProductOrders, either from the connected Quote or ProductSpec.
 */
@Singleton
@Slf4j
@RequiredArgsConstructor
public class PolicyResolver {

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

        private final ProductOfferingApiClient productOfferingApiClient;
        private final ProductSpecificationApiClient productSpecificationApiClient;
        private final QuoteApiClient quoteApiClient;
        private final ObjectMapper objectMapper;

        public Mono<List<Map<String, Object>>> 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<List<Map<String, Object>>>> 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 zipMonoList(credentialsVOMonoList);
        }

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

        }

        private Mono<List<Map<String, Object>>> 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)
                                .map(ProductSpecificationVO::getProductSpecCharacteristic)
                                .map(this::getAuthorizationPolicyFromPSC);
        }

        private Mono<List<Map<String, Object>>> 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<List<Map<String, Object>>>> 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 zipMonoList(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);
        }
}

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.http.HttpResponse;
6	import jakarta.inject.Singleton;
7	import lombok.RequiredArgsConstructor;
8	import lombok.extern.slf4j.Slf4j;
9	import org.fiware.iam.til.model.CredentialsVO;
10	import org.fiware.iam.tmforum.productcatalog.api.ProductOfferingApiClient;
11	import org.fiware.iam.tmforum.productcatalog.api.ProductSpecificationApiClient;
12	import org.fiware.iam.tmforum.productcatalog.model.ProductSpecificationRefVO;
13	import org.fiware.iam.tmforum.productcatalog.model.*;
14	import org.fiware.iam.tmforum.productorder.model.ProductOfferingRefVO;
15	import org.fiware.iam.tmforum.productorder.model.*;
16	import org.fiware.iam.tmforum.quote.api.QuoteApiClient;
17	import org.fiware.iam.tmforum.quote.model.QuoteItemVO;
18	import org.fiware.iam.tmforum.quote.model.QuoteStateTypeVO;
19	import org.fiware.iam.tmforum.quote.model.QuoteVO;
20	import reactor.core.publisher.Mono;
21
22	import java.util.List;
23	import java.util.Map;
24	import java.util.Objects;
25	import java.util.stream.Stream;
26
27	/**
28	* Extract policies from ProductOrders, either from the connected Quote or ProductSpec.
29	*/
30	@Singleton
NEW 31	@Slf4j	×
32	@RequiredArgsConstructor
33	public class PolicyResolver {
34
35	private static final String AUTHORIZATION_POLICY_KEY = "authorizationPolicy";
36	private static final String QUOTE_DELETE_ACTION = "delete";
37
38	private final ProductOfferingApiClient productOfferingApiClient;
39	private final ProductSpecificationApiClient productSpecificationApiClient;
40	private final QuoteApiClient quoteApiClient;
41	private final ObjectMapper objectMapper;
42
43	public Mono<List<Map<String, Object>>> getAuthorizationPolicy(ProductOrderVO productOrder) {
NEW 44	if (productOrder.getQuote() != null && !productOrder.getQuote().isEmpty()) {	×
NEW 45	return getAuthorizationPolicyFromQuote(productOrder.getQuote());	×
46	}
NEW 47	log.debug("No quote found, take the original offer from the order item.");	×
NEW 48	List<Mono<List<Map<String, Object>>>> credentialsVOMonoList = productOrder.getProductOrderItem()	×
NEW 49	.stream()	×
NEW 50	.filter(poi -> poi.getAction() == OrderItemActionTypeVO.ADD \|\| poi.getAction() == OrderItemActionTypeVO.MODIFY)	×
NEW 51	.map(ProductOrderItemVO::getProductOffering)	×
NEW 52	.map(ProductOfferingRefVO::getId)	×
NEW 53	.map(this::getAuthorizationPolicyFromOffer)	×
NEW 54	.toList();	×
55
NEW 56	return zipMonoList(credentialsVOMonoList);	×
57	}
58
59	private Mono<List<Map<String, Object>>> zipMonoList(List<Mono<List<Map<String, Object>>>> monoList) {
NEW 60	return Mono.zip(monoList, results -> Stream.of(results).map(r -> (List<Map<String, Object>>) r).flatMap(List::stream).toList());	×
61
62	}
63
64	private Mono<List<Map<String, Object>>> getAuthorizationPolicyFromOffer(String offerId) {
NEW 65	return productOfferingApiClient	×
NEW 66	.retrieveProductOffering(offerId, null)	×
NEW 67	.map(HttpResponse::body)	×
NEW 68	.map(ProductOfferingVO::getProductSpecification)	×
NEW 69	.map(ProductSpecificationRefVO::getId)	×
NEW 70	.flatMap(specId -> productSpecificationApiClient.retrieveProductSpecification(specId, null))	×
NEW 71	.map(HttpResponse::body)	×
NEW 72	.map(ProductSpecificationVO::getProductSpecCharacteristic)	×
NEW 73	.map(this::getAuthorizationPolicyFromPSC);	×
74	}
75
76	private Mono<List<Map<String, Object>>> getAuthorizationPolicyFromQuote(List<QuoteRefVO> quoteRefVOS) {
NEW 77	return zipMonoList(quoteRefVOS.stream()	×
NEW 78	.map(QuoteRefVO::getId)	×
NEW 79	.map(quoteId -> quoteApiClient.retrieveQuote(quoteId, null)	×
NEW 80	.map(HttpResponse::body)	×
NEW 81	.filter(quoteVO -> quoteVO.getState() == QuoteStateTypeVO.ACCEPTED)	×
NEW 82	.map(QuoteVO::getQuoteItem)	×
NEW 83	.flatMap(quoteItemList -> {	×
NEW 84	List<Mono<List<Map<String, Object>>>> configMonos = quoteItemList.stream()	×
NEW 85	.filter(item -> item.getState().equals(QuoteStateTypeVO.ACCEPTED.getValue()))	×
NEW 86	.filter(item -> !item.getAction().equals(QUOTE_DELETE_ACTION))	×
NEW 87	.map(QuoteItemVO::getProductOffering)	×
NEW 88	.map(org.fiware.iam.tmforum.quote.model.ProductOfferingRefVO::getId)	×
NEW 89	.map(this::getAuthorizationPolicyFromOffer)	×
NEW 90	.toList();	×
NEW 91	return zipMonoList(configMonos);	×
92	}))
NEW 93	.toList());	×
94	}
95
96	private List<Map<String, Object>> getAuthorizationPolicyFromPSC(List<ProductSpecificationCharacteristicVO> pscList) {
NEW 97	return pscList.stream()	×
NEW 98	.filter(psc -> psc.getValueType().equals(AUTHORIZATION_POLICY_KEY))	×
NEW 99	.findFirst()	×
NEW 100	.map(productSpecificationCharacteristicVO -> productSpecificationCharacteristicVO	×
NEW 101	.getProductSpecCharacteristicValue()	×
NEW 102	.stream()	×
NEW 103	.map(CharacteristicValueSpecificationVO::getValue)	×
NEW 104	.map(value -> {	×
105	try {
NEW 106	List<Map<String, Object>> policies = objectMapper.convertValue(value, new TypeReference<List<Map<String, Object>>>() {	×
107	});
NEW 108	log.debug("Policy is {}", policies);	×
NEW 109	return policies;	×
NEW 110	} catch (IllegalArgumentException iae) {	×
NEW 111	log.warn("The characteristic value is invalid.", iae);	×
NEW 112	return null;	×
113	}
114	})
NEW 115	.filter(Objects::nonNull)	×
NEW 116	.flatMap(List::stream)	×
NEW 117	.toList()).orElseGet(List::of);	×
118	}
119	}

FIWARE / contract-management / #58

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