FIWARE / contract-management / #31

Committed 04 Apr 2025 09:14AM UTC coverage: 1.9% (+0.9%) from 0.982%

Build # #31

Build Type

Committed by

Commit Message

add json schemas to extend offerings and quotes

Pull Request Pull Request #5: integrate contract negotiation

Run Details

29 of 247 new or added lines in 9 files covered. (11.74%)

5 existing lines in 2 files now uncovered.

644 of 33897 relevant lines covered (1.9%)

0.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.46

/src/main/java/org/fiware/iam/dsp/RainbowAdapter.java

package org.fiware.iam.dsp;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.client.exceptions.HttpClientResponseException;
import jakarta.inject.Singleton;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.exception.RainbowException;
import org.fiware.rainbow.api.AgreementApiClient;
import org.fiware.rainbow.api.ContractApiClient;
import org.fiware.rainbow.api.ParticipantApiClient;
import org.fiware.rainbow.model.*;
import reactor.core.publisher.Mono;

import java.util.Map;
import java.util.UUID;


/**
 * Adapter to handle communication with Rainbow.
 */
@Singleton
@RequiredArgsConstructor
@Slf4j
public class RainbowAdapter {

        private final AgreementApiClient agreementApiClient;
        private final ContractApiClient contractApiClient;
        private final ParticipantApiClient participantApiClient;
        private final ObjectMapper objectMapper;

        /**
         * Create the agreement for the given organization and offer
         */
        public Mono<AgreementVO> createAgreement(String organizationId, String offeringId) {
                AgreementCreateVO agreementCreateVO = new AgreementCreateVO()
                                .identity(organizationId)
                                .dataServiceId(offeringId);

                return agreementApiClient
                                .createAgreement(agreementCreateVO)
                                .map(HttpResponse::body)
                                .map(body -> objectMapper.convertValue(body, AgreementVO.class))
                                .onErrorMap(t -> {
                                        throw new RainbowException("Was not able to create agreement");
                                });
        }

        private Mono<LastOfferVO> getTheLastOffer(String processId) {
                return contractApiClient.getLastOfferForProcess(processId)
                                .map(HttpResponse::body)
                                .onErrorMap(t -> new RainbowException(String.format("Was not able to find the last offer for %s.", processId)));
        }

        public Mono<AgreementVO> createAgreementAfterNegotiation(String providerId, String consumerOrganization, String providerOrganization) {
                return getNegotiationProcess(providerId)
                                .flatMap(providerNegotiationVO ->
                                                getTheLastOffer(providerNegotiationVO.getCnProcessId())
                                                                .flatMap(lastOfferVO -> {
                                                                        OdrlAgreementVO agreementVO = new OdrlAgreementVO()
                                                                                        .atId("urn:uuid:" + UUID.randomUUID())
                                                                                        .odrlColonTarget(lastOfferVO.getOfferContent().getOdrlColonTarget())
                                                                                        .odrlColonAssignee(prefixDid(consumerOrganization))
                                                                                        .odrlColonAssigner(prefixDid(providerOrganization))
                                                                                        .odrlColonPermission(lastOfferVO.getOfferContent().getOdrlColonPermission());
                                                                        AgreementRequestVO agreementRequestVO = new AgreementRequestVO()
                                                                                        .dspaceColonProviderParticipantId(prefixDid(providerOrganization))
                                                                                        .dspaceColonConsumerParticipantId(prefixDid(consumerOrganization))
                                                                                        .odrlColonAgreement(agreementVO);
                                                                        return contractApiClient.createAgreementForProcess(providerNegotiationVO.getCnProcessId(), lastOfferVO.getCnMessageId(), agreementRequestVO);
                                                                }))
                                .map(HttpResponse::body)
                                .map(r -> new AgreementVO())
                                .onErrorMap(t -> {
                                        throw new RainbowException("Was not able to create agreement");
                                });

        }

        public Mono<AgreementVO> getAgreement(String processId) {
                return contractApiClient.getAgreement(processId)
                                .onErrorMap(t -> {
                                        throw new RainbowException("Was not able to create agreement");
                                })
                                .map(HttpResponse::body);
        }

        /**
         * Delete the agreement with the given id
         */
        public Mono<Boolean> deleteAgreement(String agreementId) {
                return agreementApiClient.deleteAgreementById(agreementId)
                                .map(objectHttpResponse -> {
                                        if (objectHttpResponse.status().equals(HttpStatus.ACCEPTED)) {
                                                return true;
                                        }
                                        return false;
                                })
                                .onErrorResume(t -> Mono.just(false));
        }

        /**
         * Create the given negotiation request at rainbow and return the providerId
         */
        public Mono<String> createNegotiationRequest(NegotiationRequestVO negotiationRequestVO) {
                return contractApiClient.createRequest(negotiationRequestVO)
                                .map(HttpResponse::body)
                                .map(NegotiationVO::getDspaceColonProviderPid)
                                .onErrorMap(t -> {
                                        throw new RainbowException("Was not able to create negotiation request.", t);
                                });
        }

        public Mono<String> getNegotiationProcessState(String providerId) {
                return getNegotiationProcess(providerId)
                                .map(ProviderNegotiationVO::getState);
        }

        public Mono<ProviderNegotiationVO> getNegotiationProcess(String providerId) {
                return contractApiClient.getProcessById(providerId)
                                .map(HttpResponse::body)
                                .onErrorMap(t -> new RainbowException(String.format("Was not able to find negotiation process %s.", providerId), t));
        }

        public Mono<Object> updateNegotiationProcessByProviderId(String providerId, String state) {
                return contractApiClient.getProcessById(providerId)
                                .map(HttpResponse::body)
                                .flatMap(pn -> {
                                        NegotiationProcessVO negotiationProcessVO = new NegotiationProcessVO()
                                                        .dspaceColonConsumerPid(pn.getConsumerId())
                                                        .dspaceColonProviderPid(pn.getProviderId())
                                                        .dspaceColonState(state);
                                        return contractApiClient.updateProcessById(pn.getCnProcessId(), negotiationProcessVO);
                                })
                                .map(HttpResponse::body)
                                .onErrorMap(t -> new RainbowException(String.format("Was not able to update negotiation process %s to %s.", providerId, state), t));
        }


        public Mono<Boolean> isParticipant(String id) {
                return participantApiClient.getParticipantById(prefixDid(id))
                                .map(r -> true)
                                .onErrorResume(t -> {
                                        if (t instanceof HttpClientResponseException re && re.getStatus().equals(HttpStatus.NOT_FOUND)) {
                                                return Mono.just(false);
                                        }
                                        throw new RainbowException(String.format("Was not able to check participant %s.", id), t);
                                });
        }

        public Mono<String> createParticipant(String participantId, String participantType) {
                return isParticipant(participantId)
                                .filter(r -> !r)
                                .flatMap(p -> participantApiClient.createParticipant(new ParticipantVO()
                                                                .dspaceColonParticipantId(prefixDid(participantId))
                                                                .dspaceColonParticipantType(participantType)
                                                                // set empty, rainbow does not support null
                                                                .dspaceColonParticipantBaseUrl("")
                                                                .dspaceColonExtraFields(Map.of()))
                                                .onErrorMap(t -> {
                                                        throw new RainbowException(String.format("Was not able to create the participant %s with type %s.", participantId, participantType), t);
                                                })
                                                .map(HttpResponse::body)
                                                .map(ParticipantVO::getDspaceColonParticipantId))
                                .defaultIfEmpty(prefixDid(participantId));
        }

        private static String prefixDid(String did) {
                return String.format("urn:%s", did);
        }

        private static String removeUrnPrefix(String urnDid) {
                return urnDid.replaceFirst("urn:", "");
        }
}

1	package org.fiware.iam.dsp;
2
3	import com.fasterxml.jackson.databind.ObjectMapper;
4	import io.micronaut.http.HttpResponse;
5	import io.micronaut.http.HttpStatus;
6	import io.micronaut.http.client.exceptions.HttpClientResponseException;
7	import jakarta.inject.Singleton;
8	import lombok.RequiredArgsConstructor;
9	import lombok.extern.slf4j.Slf4j;
10	import org.fiware.iam.exception.RainbowException;
11	import org.fiware.rainbow.api.AgreementApiClient;
12	import org.fiware.rainbow.api.ContractApiClient;
13	import org.fiware.rainbow.api.ParticipantApiClient;
14	import org.fiware.rainbow.model.*;
15	import reactor.core.publisher.Mono;
16
17	import java.util.Map;
18	import java.util.UUID;
19
20
21	/**
22	* Adapter to handle communication with Rainbow.
23	*/
24	@Singleton
25	@RequiredArgsConstructor
26	@Slf4j	1✔
27	public class RainbowAdapter {
28
29	private final AgreementApiClient agreementApiClient;
30	private final ContractApiClient contractApiClient;
31	private final ParticipantApiClient participantApiClient;
32	private final ObjectMapper objectMapper;
33
34	/**
35	* Create the agreement for the given organization and offer
36	*/
37	public Mono<AgreementVO> createAgreement(String organizationId, String offeringId) {
38	AgreementCreateVO agreementCreateVO = new AgreementCreateVO()	1✔
39	.identity(organizationId)	1✔
40	.dataServiceId(offeringId);	1✔
41
42	return agreementApiClient	1✔
43	.createAgreement(agreementCreateVO)	1✔
44	.map(HttpResponse::body)	1✔
45	.map(body -> objectMapper.convertValue(body, AgreementVO.class))	1✔
46	.onErrorMap(t -> {	1✔
47	throw new RainbowException("Was not able to create agreement");	1✔
48	});
49	}
50
51	private Mono<LastOfferVO> getTheLastOffer(String processId) {
NEW 52	return contractApiClient.getLastOfferForProcess(processId)	×
NEW 53	.map(HttpResponse::body)	×
NEW 54	.onErrorMap(t -> new RainbowException(String.format("Was not able to find the last offer for %s.", processId)));	×
55	}
56
57	public Mono<AgreementVO> createAgreementAfterNegotiation(String providerId, String consumerOrganization, String providerOrganization) {
NEW 58	return getNegotiationProcess(providerId)	×
NEW 59	.flatMap(providerNegotiationVO ->	×
NEW 60	getTheLastOffer(providerNegotiationVO.getCnProcessId())	×
NEW 61	.flatMap(lastOfferVO -> {	×
NEW 62	OdrlAgreementVO agreementVO = new OdrlAgreementVO()	×
NEW 63	.atId("urn:uuid:" + UUID.randomUUID())	×
NEW 64	.odrlColonTarget(lastOfferVO.getOfferContent().getOdrlColonTarget())	×
NEW 65	.odrlColonAssignee(prefixDid(consumerOrganization))	×
NEW 66	.odrlColonAssigner(prefixDid(providerOrganization))	×
NEW 67	.odrlColonPermission(lastOfferVO.getOfferContent().getOdrlColonPermission());	×
NEW 68	AgreementRequestVO agreementRequestVO = new AgreementRequestVO()	×
NEW 69	.dspaceColonProviderParticipantId(prefixDid(providerOrganization))	×
NEW 70	.dspaceColonConsumerParticipantId(prefixDid(consumerOrganization))	×
NEW 71	.odrlColonAgreement(agreementVO);	×
NEW 72	return contractApiClient.createAgreementForProcess(providerNegotiationVO.getCnProcessId(), lastOfferVO.getCnMessageId(), agreementRequestVO);	×
73	}))
NEW 74	.map(HttpResponse::body)	×
NEW 75	.map(r -> new AgreementVO())	×
NEW 76	.onErrorMap(t -> {	×
NEW 77	throw new RainbowException("Was not able to create agreement");	×
78	});
79
80	}
81
82	public Mono<AgreementVO> getAgreement(String processId) {
NEW 83	return contractApiClient.getAgreement(processId)	×
NEW 84	.onErrorMap(t -> {	×
NEW 85	throw new RainbowException("Was not able to create agreement");	×
86	})
NEW 87	.map(HttpResponse::body);	×
88	}
89
90	/**
91	* Delete the agreement with the given id
92	*/
93	public Mono<Boolean> deleteAgreement(String agreementId) {
94	return agreementApiClient.deleteAgreementById(agreementId)	1✔
95	.map(objectHttpResponse -> {	1✔
96	if (objectHttpResponse.status().equals(HttpStatus.ACCEPTED)) {	1✔
97	return true;	1✔
98	}
99	return false;	1✔
100	})
101	.onErrorResume(t -> Mono.just(false));	1✔
102	}
103
104	/**
105	* Create the given negotiation request at rainbow and return the providerId
106	*/
107	public Mono<String> createNegotiationRequest(NegotiationRequestVO negotiationRequestVO) {
NEW 108	return contractApiClient.createRequest(negotiationRequestVO)	×
NEW 109	.map(HttpResponse::body)	×
NEW 110	.map(NegotiationVO::getDspaceColonProviderPid)	×
NEW 111	.onErrorMap(t -> {	×
NEW 112	throw new RainbowException("Was not able to create negotiation request.", t);	×
113	});
114	}
115
116	public Mono<String> getNegotiationProcessState(String providerId) {
NEW 117	return getNegotiationProcess(providerId)	×
NEW 118	.map(ProviderNegotiationVO::getState);	×
119	}
120
121	public Mono<ProviderNegotiationVO> getNegotiationProcess(String providerId) {
NEW 122	return contractApiClient.getProcessById(providerId)	×
NEW 123	.map(HttpResponse::body)	×
NEW 124	.onErrorMap(t -> new RainbowException(String.format("Was not able to find negotiation process %s.", providerId), t));	×
125	}
126
127	public Mono<Object> updateNegotiationProcessByProviderId(String providerId, String state) {
NEW 128	return contractApiClient.getProcessById(providerId)	×
NEW 129	.map(HttpResponse::body)	×
NEW 130	.flatMap(pn -> {	×
NEW 131	NegotiationProcessVO negotiationProcessVO = new NegotiationProcessVO()	×
NEW 132	.dspaceColonConsumerPid(pn.getConsumerId())	×
NEW 133	.dspaceColonProviderPid(pn.getProviderId())	×
NEW 134	.dspaceColonState(state);	×
NEW 135	return contractApiClient.updateProcessById(pn.getCnProcessId(), negotiationProcessVO);	×
136	})
NEW 137	.map(HttpResponse::body)	×
NEW 138	.onErrorMap(t -> new RainbowException(String.format("Was not able to update negotiation process %s to %s.", providerId, state), t));	×
139	}
140
141
142	public Mono<Boolean> isParticipant(String id) {
143	return participantApiClient.getParticipantById(prefixDid(id))	1✔
144	.map(r -> true)	1✔
145	.onErrorResume(t -> {	1✔
146	if (t instanceof HttpClientResponseException re && re.getStatus().equals(HttpStatus.NOT_FOUND)) {	1✔
147	return Mono.just(false);	1✔
148	}
149	throw new RainbowException(String.format("Was not able to check participant %s.", id), t);	1✔
150	});
151	}
152
153	public Mono<String> createParticipant(String participantId, String participantType) {
154	return isParticipant(participantId)	1✔
155	.filter(r -> !r)	1✔
156	.flatMap(p -> participantApiClient.createParticipant(new ParticipantVO()	1✔
157	.dspaceColonParticipantId(prefixDid(participantId))	1✔
158	.dspaceColonParticipantType(participantType)	1✔
159	// set empty, rainbow does not support null
160	.dspaceColonParticipantBaseUrl("")	1✔
161	.dspaceColonExtraFields(Map.of()))	1✔
162	.onErrorMap(t -> {	1✔
NEW 163	throw new RainbowException(String.format("Was not able to create the participant %s with type %s.", participantId, participantType), t);	×
164	})
165	.map(HttpResponse::body)	1✔
166	.map(ParticipantVO::getDspaceColonParticipantId))	1✔
167	.defaultIfEmpty(prefixDid(participantId));	1✔
168	}
169
170	private static String prefixDid(String did) {
171	return String.format("urn:%s", did);	1✔
172	}
173
174	private static String removeUrnPrefix(String urnDid) {
NEW 175	return urnDid.replaceFirst("urn:", "");	×
176	}
177	}

FIWARE / contract-management / #31

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