FIWARE / contract-management / #69

Committed 30 Oct 2025 07:38AM UTC coverage: 1.686% (+0.04%) from 1.651%

Build # #69

Build Type

Committed by

Commit Message

improve organization creation and cleanup

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/management/ContractManagementProductOrderHandler.java

package org.fiware.iam.management;

import io.micronaut.context.annotation.Requires;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpResponseFactory;
import io.micronaut.http.HttpStatus;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.cm.model.CredentialVO;
import org.fiware.iam.cm.model.OdrlPolicyJsonVO;
import org.fiware.iam.cm.model.OrderEventVO;
import org.fiware.iam.configuration.GeneralProperties;
import org.fiware.iam.domain.ContractManagement;
import org.fiware.iam.handlers.ProductOrderHandler;
import org.fiware.iam.tmforum.CredentialsConfigResolver;
import org.fiware.iam.tmforum.OrganizationResolver;
import org.fiware.iam.tmforum.PolicyResolver;
import org.fiware.iam.tmforum.productorder.model.ProductOrderVO;
import reactor.core.publisher.Mono;
import reactor.util.function.Tuple2;

import java.util.*;
import java.util.function.BiFunction;

@Requires(condition = GeneralProperties.CentralMarketplaceCondition.class)
@RequiredArgsConstructor
@Singleton
@Slf4j
public class ContractManagementProductOrderHandler implements ProductOrderHandler {

    private final ContractManagementAdapter contractManagementAdapter;
    private final OrganizationResolver organizationResolver;
    private final CredentialsConfigResolver credentialsConfigResolver;
    private final PolicyResolver policyResolver;
    private final CMMapper cmMapper;

    @Override
    public Mono<HttpResponse<?>> handleProductOrderComplete(String organizationId, ProductOrderVO productOrderVO) {
        return handleOrderEvent(organizationId, productOrderVO, contractManagementAdapter::handleOrderStart);
    }


    @Override
    public Mono<HttpResponse<?>> handleProductOrderStop(String organizationId, ProductOrderVO productOrderVO) {
        return handleOrderEvent(organizationId, productOrderVO, contractManagementAdapter::handleOrderStop);
    }

    @Override
    public Mono<HttpResponse<?>> handleProductOrderNegotiation(String organizationId, ProductOrderVO productOrderVO) {
        // nothing to do in negotiations
        return Mono.just(HttpResponse.noContent());
    }


    private Mono<HttpResponse<?>> handleOrderEvent(String organizationId, ProductOrderVO productOrderVO, BiFunction<ContractManagement, OrderEventVO, Mono<HttpResponse>> handler) {
        return organizationResolver.getDID(organizationId)
                .flatMap(did -> {
                    Mono<List<PolicyResolver.PolicyConfig>> policyConfigs = policyResolver.getAuthorizationPolicy(productOrderVO);
                    Mono<List<CredentialsConfigResolver.CredentialConfig>> credentialConfigs = credentialsConfigResolver.getCredentialsConfig(productOrderVO);
                    return Mono.zipDelayError(policyConfigs, credentialConfigs)
                            .map(resultTuple -> toOrderMap(productOrderVO, did, resultTuple))
                            .flatMap(orderMap -> {
                                List<Mono<HttpResponse>> orderResponses = orderMap.entrySet()
                                        .stream()
                                        // only external configs should be handled
                                        .filter(orderMapEntry -> !orderMapEntry.getKey().isLocal())
                                        .map(orderMapEntry -> handler.apply(orderMapEntry.getKey(), orderMapEntry.getValue()))
                                        .toList();
                                if (orderResponses.isEmpty()) {
                                    return Mono.just(HttpResponseFactory.INSTANCE.status(HttpStatus.NO_CONTENT));
                                }
                                return Mono.zip(orderResponses, responses -> Arrays.stream(responses)
                                        .filter(HttpResponse.class::isInstance)
                                        .map(HttpResponse.class::cast)
                                        .map(HttpResponse::getStatus)
                                        .map(HttpStatus::getCode)
                                        .map(res -> res >= 200 && res < 300)
                                        .filter(isSuccess -> !isSuccess)
                                        .map(s -> HttpResponseFactory.INSTANCE.status(HttpStatus.BAD_GATEWAY))
                                        .findAny()
                                        .orElse(HttpResponseFactory.INSTANCE.status(HttpStatus.NO_CONTENT))
                                );
                            });
                });
    }

    private Map<ContractManagement, OrderEventVO> toOrderMap(ProductOrderVO productOrderVO, String did, Tuple2<List<PolicyResolver.PolicyConfig>, List<CredentialsConfigResolver.CredentialConfig>> resultTuple) {
        Map<ContractManagement, OrderEventVO> orderMap = new HashMap<>();
        resultTuple.getT1()
                .forEach(policyConfig -> {
                    List<OdrlPolicyJsonVO> odrlPolicies = policyConfig.policies().stream()
                            .map(cmMapper::map)
                            .toList();
                    if (orderMap.containsKey(policyConfig.contractManagement())) {
                        OrderEventVO orderVO = orderMap.get(policyConfig.contractManagement());
                        List<OdrlPolicyJsonVO> allPolicies = new ArrayList<>(orderVO.getPolicies());
                        allPolicies.addAll(odrlPolicies);
                        orderVO.setPolicies(allPolicies);
                        orderMap.put(policyConfig.contractManagement(), orderVO);
                    } else {
                        orderMap.put(policyConfig.contractManagement(), new OrderEventVO()
                                .orderId(productOrderVO.getId())
                                .customerId(did)
                                .policies(odrlPolicies));
                    }
                });
        resultTuple.getT2()
                .forEach(cc -> {
                    List<CredentialVO> credentials = cc.credentialsVOS().stream()
                            .map(cmMapper::map)
                            .toList();
                    if (orderMap.containsKey(cc.contractManagement())) {
                        OrderEventVO orderVO = orderMap.get(cc.contractManagement());
                        List<CredentialVO> allCredentials = Optional.ofNullable(orderVO.getCredentialsConfig()).map(ArrayList::new).orElse(new ArrayList<>());
                        allCredentials.addAll(credentials);
                        orderVO.setCredentialsConfig(allCredentials);
                        orderMap.put(cc.contractManagement(), orderVO);
                    } else {
                        orderMap.put(cc.contractManagement(), new OrderEventVO()
                                .orderId(productOrderVO.getId())
                                .customerId(did)
                                .credentialsConfig(credentials));
                    }
                });
        return orderMap;
    }

}

1	package org.fiware.iam.management;
2
3	import io.micronaut.context.annotation.Requires;
4	import io.micronaut.http.HttpResponse;
5	import io.micronaut.http.HttpResponseFactory;
6	import io.micronaut.http.HttpStatus;
7	import jakarta.inject.Singleton;
8	import lombok.RequiredArgsConstructor;
9	import lombok.extern.slf4j.Slf4j;
10	import org.fiware.iam.cm.model.CredentialVO;
11	import org.fiware.iam.cm.model.OdrlPolicyJsonVO;
12	import org.fiware.iam.cm.model.OrderEventVO;
13	import org.fiware.iam.configuration.GeneralProperties;
14	import org.fiware.iam.domain.ContractManagement;
15	import org.fiware.iam.handlers.ProductOrderHandler;
16	import org.fiware.iam.tmforum.CredentialsConfigResolver;
17	import org.fiware.iam.tmforum.OrganizationResolver;
18	import org.fiware.iam.tmforum.PolicyResolver;
19	import org.fiware.iam.tmforum.productorder.model.ProductOrderVO;
20	import reactor.core.publisher.Mono;
21	import reactor.util.function.Tuple2;
22
23	import java.util.*;
24	import java.util.function.BiFunction;
25
26	@Requires(condition = GeneralProperties.CentralMarketplaceCondition.class)
27	@RequiredArgsConstructor
28	@Singleton
NEW 29	@Slf4j	×
30	public class ContractManagementProductOrderHandler implements ProductOrderHandler {
31
32	private final ContractManagementAdapter contractManagementAdapter;
33	private final OrganizationResolver organizationResolver;
34	private final CredentialsConfigResolver credentialsConfigResolver;
35	private final PolicyResolver policyResolver;
36	private final CMMapper cmMapper;
37
38	@Override
39	public Mono<HttpResponse<?>> handleProductOrderComplete(String organizationId, ProductOrderVO productOrderVO) {
NEW 40	return handleOrderEvent(organizationId, productOrderVO, contractManagementAdapter::handleOrderStart);	×
41	}
42
43
44	@Override
45	public Mono<HttpResponse<?>> handleProductOrderStop(String organizationId, ProductOrderVO productOrderVO) {
NEW 46	return handleOrderEvent(organizationId, productOrderVO, contractManagementAdapter::handleOrderStop);	×
47	}
48
49	@Override
50	public Mono<HttpResponse<?>> handleProductOrderNegotiation(String organizationId, ProductOrderVO productOrderVO) {
51	// nothing to do in negotiations
NEW 52	return Mono.just(HttpResponse.noContent());	×
53	}
54
55
56	private Mono<HttpResponse<?>> handleOrderEvent(String organizationId, ProductOrderVO productOrderVO, BiFunction<ContractManagement, OrderEventVO, Mono<HttpResponse>> handler) {
NEW 57	return organizationResolver.getDID(organizationId)	×
NEW 58	.flatMap(did -> {	×
NEW 59	Mono<List<PolicyResolver.PolicyConfig>> policyConfigs = policyResolver.getAuthorizationPolicy(productOrderVO);	×
NEW 60	Mono<List<CredentialsConfigResolver.CredentialConfig>> credentialConfigs = credentialsConfigResolver.getCredentialsConfig(productOrderVO);	×
NEW 61	return Mono.zipDelayError(policyConfigs, credentialConfigs)	×
NEW 62	.map(resultTuple -> toOrderMap(productOrderVO, did, resultTuple))	×
NEW 63	.flatMap(orderMap -> {	×
NEW 64	List<Mono<HttpResponse>> orderResponses = orderMap.entrySet()	×
NEW 65	.stream()	×
66	// only external configs should be handled
NEW 67	.filter(orderMapEntry -> !orderMapEntry.getKey().isLocal())	×
NEW 68	.map(orderMapEntry -> handler.apply(orderMapEntry.getKey(), orderMapEntry.getValue()))	×
NEW 69	.toList();	×
NEW 70	if (orderResponses.isEmpty()) {	×
NEW 71	return Mono.just(HttpResponseFactory.INSTANCE.status(HttpStatus.NO_CONTENT));	×
72	}
NEW 73	return Mono.zip(orderResponses, responses -> Arrays.stream(responses)	×
NEW 74	.filter(HttpResponse.class::isInstance)	×
NEW 75	.map(HttpResponse.class::cast)	×
NEW 76	.map(HttpResponse::getStatus)	×
NEW 77	.map(HttpStatus::getCode)	×
NEW 78	.map(res -> res >= 200 && res < 300)	×
NEW 79	.filter(isSuccess -> !isSuccess)	×
NEW 80	.map(s -> HttpResponseFactory.INSTANCE.status(HttpStatus.BAD_GATEWAY))	×
NEW 81	.findAny()	×
NEW 82	.orElse(HttpResponseFactory.INSTANCE.status(HttpStatus.NO_CONTENT))	×
83	);
84	});
85	});
86	}
87
88	private Map<ContractManagement, OrderEventVO> toOrderMap(ProductOrderVO productOrderVO, String did, Tuple2<List<PolicyResolver.PolicyConfig>, List<CredentialsConfigResolver.CredentialConfig>> resultTuple) {
NEW 89	Map<ContractManagement, OrderEventVO> orderMap = new HashMap<>();	×
NEW 90	resultTuple.getT1()	×
NEW 91	.forEach(policyConfig -> {	×
NEW 92	List<OdrlPolicyJsonVO> odrlPolicies = policyConfig.policies().stream()	×
NEW 93	.map(cmMapper::map)	×
NEW 94	.toList();	×
NEW 95	if (orderMap.containsKey(policyConfig.contractManagement())) {	×
NEW 96	OrderEventVO orderVO = orderMap.get(policyConfig.contractManagement());	×
NEW 97	List<OdrlPolicyJsonVO> allPolicies = new ArrayList<>(orderVO.getPolicies());	×
NEW 98	allPolicies.addAll(odrlPolicies);	×
NEW 99	orderVO.setPolicies(allPolicies);	×
NEW 100	orderMap.put(policyConfig.contractManagement(), orderVO);	×
NEW 101	} else {	×
NEW 102	orderMap.put(policyConfig.contractManagement(), new OrderEventVO()	×
NEW 103	.orderId(productOrderVO.getId())	×
NEW 104	.customerId(did)	×
NEW 105	.policies(odrlPolicies));	×
106	}
NEW 107	});	×
NEW 108	resultTuple.getT2()	×
NEW 109	.forEach(cc -> {	×
NEW 110	List<CredentialVO> credentials = cc.credentialsVOS().stream()	×
NEW 111	.map(cmMapper::map)	×
NEW 112	.toList();	×
NEW 113	if (orderMap.containsKey(cc.contractManagement())) {	×
NEW 114	OrderEventVO orderVO = orderMap.get(cc.contractManagement());	×
NEW 115	List<CredentialVO> allCredentials = Optional.ofNullable(orderVO.getCredentialsConfig()).map(ArrayList::new).orElse(new ArrayList<>());	×
NEW 116	allCredentials.addAll(credentials);	×
NEW 117	orderVO.setCredentialsConfig(allCredentials);	×
NEW 118	orderMap.put(cc.contractManagement(), orderVO);	×
NEW 119	} else {	×
NEW 120	orderMap.put(cc.contractManagement(), new OrderEventVO()	×
NEW 121	.orderId(productOrderVO.getId())	×
NEW 122	.customerId(did)	×
NEW 123	.credentialsConfig(credentials));	×
124	}
NEW 125	});	×
NEW 126	return orderMap;	×
127	}
128
129	}

FIWARE / contract-management / #69

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