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/pap/PapProductOrderHandler.java

package org.fiware.iam.pap;

import io.micronaut.context.annotation.Requires;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.configuration.GeneralProperties;
import org.fiware.iam.handlers.ProductOrderHandler;
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 java.util.List;
import java.util.Map;
import java.util.stream.Stream;

/**
 * Handler implementation to publish product order information to the pap
 */
@Requires(condition = GeneralProperties.PapCondition.class)
@RequiredArgsConstructor
@Singleton
@Slf4j
public class PapProductOrderHandler implements ProductOrderHandler {

    private final PolicyResolver policyResolver;
    private final OrganizationResolver organizationResolver;
    private final PAPAdapter papAdapter;

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

    @Override
    public Mono<HttpResponse<?>> handleProductOrderStop(String organizationId, ProductOrderVO productOrderVO) {

        return policyResolver
                .getAuthorizationPolicy(productOrderVO)
                .map(this::filterLocalPolicies)
                .flatMap(policies -> Mono.zipDelayError(policies.stream()
                                .map(p -> papAdapter.deletePolicy(productOrderVO.getId(), p)).toList(),
                        results -> {
                            if (Stream.of(results).map(r -> (Boolean) r).toList().contains(false)) {
                                return HttpResponse.status(HttpStatus.BAD_GATEWAY);
                            }
                            return HttpResponse.ok();
                        }
                ));
    }

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

    private Mono<HttpResponse<?>> createPolicy(String organizationId, ProductOrderVO productOrderVO) {

        return organizationResolver.getDID(organizationId)
                .flatMap(did -> policyResolver
                        .getAuthorizationPolicy(productOrderVO)
                        .map(this::filterLocalPolicies)
                        .flatMap(policies -> Mono.zipDelayError(policies.stream()
                                        .map(p -> papAdapter.createPolicy(did, productOrderVO.getId(), p)).toList(),
                                results -> {
                                    if (Stream.of(results).map(r -> (Boolean) r).toList().contains(false)) {
                                        return HttpResponse.status(HttpStatus.BAD_GATEWAY);
                                    }
                                    return HttpResponse.ok();
                                }
                        )));
    }

    // only return policies intended for local
    private List<Map<String, Object>> filterLocalPolicies(List<PolicyResolver.PolicyConfig> policyConfigs) {
        return policyConfigs.stream()
                .filter(policyConfig -> policyConfig.contractManagement().isLocal())
                .map(PolicyResolver.PolicyConfig::policies)
                .flatMap(List::stream)
                .toList();
    }
}

1	package org.fiware.iam.pap;
2
3	import io.micronaut.context.annotation.Requires;
4	import io.micronaut.http.HttpResponse;
5	import io.micronaut.http.HttpStatus;
6	import jakarta.inject.Singleton;
7	import lombok.RequiredArgsConstructor;
8	import lombok.extern.slf4j.Slf4j;
9	import org.fiware.iam.configuration.GeneralProperties;
10	import org.fiware.iam.handlers.ProductOrderHandler;
11	import org.fiware.iam.tmforum.OrganizationResolver;
12	import org.fiware.iam.tmforum.PolicyResolver;
13	import org.fiware.iam.tmforum.productorder.model.ProductOrderVO;
14	import reactor.core.publisher.Mono;
15
16	import java.util.List;
17	import java.util.Map;
18	import java.util.stream.Stream;
19
20	/**
21	* Handler implementation to publish product order information to the pap
22	*/
23	@Requires(condition = GeneralProperties.PapCondition.class)
24	@RequiredArgsConstructor
25	@Singleton
NEW 26	@Slf4j	×
27	public class PapProductOrderHandler implements ProductOrderHandler {
28
29	private final PolicyResolver policyResolver;
30	private final OrganizationResolver organizationResolver;
31	private final PAPAdapter papAdapter;
32
33	@Override
34	public Mono<HttpResponse<?>> handleProductOrderComplete(String organizationId, ProductOrderVO productOrderVO) {
NEW 35	return createPolicy(organizationId, productOrderVO);	×
36	}
37
38	@Override
39	public Mono<HttpResponse<?>> handleProductOrderStop(String organizationId, ProductOrderVO productOrderVO) {
40
NEW 41	return policyResolver	×
NEW 42	.getAuthorizationPolicy(productOrderVO)	×
NEW 43	.map(this::filterLocalPolicies)	×
NEW 44	.flatMap(policies -> Mono.zipDelayError(policies.stream()	×
NEW 45	.map(p -> papAdapter.deletePolicy(productOrderVO.getId(), p)).toList(),	×
46	results -> {
NEW 47	if (Stream.of(results).map(r -> (Boolean) r).toList().contains(false)) {	×
NEW 48	return HttpResponse.status(HttpStatus.BAD_GATEWAY);	×
49	}
NEW 50	return HttpResponse.ok();	×
51	}
52	));
53	}
54
55	@Override
56	public Mono<HttpResponse<?>> handleProductOrderNegotiation(String organizationId, ProductOrderVO productOrderVO) {
57	// nothing to do
NEW 58	return Mono.just(HttpResponse.noContent());	×
59	}
60
61	private Mono<HttpResponse<?>> createPolicy(String organizationId, ProductOrderVO productOrderVO) {
62
NEW 63	return organizationResolver.getDID(organizationId)	×
NEW 64	.flatMap(did -> policyResolver	×
NEW 65	.getAuthorizationPolicy(productOrderVO)	×
NEW 66	.map(this::filterLocalPolicies)	×
NEW 67	.flatMap(policies -> Mono.zipDelayError(policies.stream()	×
NEW 68	.map(p -> papAdapter.createPolicy(did, productOrderVO.getId(), p)).toList(),	×
69	results -> {
NEW 70	if (Stream.of(results).map(r -> (Boolean) r).toList().contains(false)) {	×
NEW 71	return HttpResponse.status(HttpStatus.BAD_GATEWAY);	×
72	}
NEW 73	return HttpResponse.ok();	×
74	}
75	)));
76	}
77
78	// only return policies intended for local
79	private List<Map<String, Object>> filterLocalPolicies(List<PolicyResolver.PolicyConfig> policyConfigs) {
NEW 80	return policyConfigs.stream()	×
NEW 81	.filter(policyConfig -> policyConfig.contractManagement().isLocal())	×
NEW 82	.map(PolicyResolver.PolicyConfig::policies)	×
NEW 83	.flatMap(List::stream)	×
NEW 84	.toList();	×
85	}
86	}

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