FIWARE / contract-management / #68

Committed 29 Oct 2025 11:26AM UTC coverage: 1.686% (+0.04%) from 1.651%

Build # #68

Build Type

Committed by

Commit Message

fixes from pr review

Pull Request Pull Request #12: Support for central marketplace and policy creation

Run Details

117 of 1238 new or added lines in 31 files covered. (9.45%)

5 existing lines in 2 files now uncovered.

587 of 34807 relevant lines covered (1.69%)

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;

import static org.fiware.iam.tmforum.OrganizationResolver.PROVIDER_ROLE;

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

FIWARE / contract-management / #68

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