FIWARE / contract-management / #26

Committed 28 Jan 2025 10:59AM UTC coverage: 0.982% (-0.6%) from 1.629%

Build # #26

Build Type

push

Committed by

Commit Message

Merge pull request #3 from FIWARE/tpp-integration

Tpp integration

Run Details

99 of 500 new or added lines in 14 files covered. (19.8%)

4 existing lines in 3 files now uncovered.

281 of 28625 relevant lines covered (0.98%)

0.01 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/handlers/CatalogEventHandler.java

package org.fiware.iam.tmforum.handlers;

import com.fasterxml.jackson.databind.ObjectMapper;
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.RainbowMapper;
import org.fiware.iam.tmforum.productcatalog.model.*;
import org.fiware.rainbow.api.CatalogApiClient;
import org.fiware.rainbow.model.NewCatalogVO;
import reactor.core.publisher.Mono;

import java.util.List;
import java.util.Map;
import java.util.Optional;

@RequiredArgsConstructor
@Singleton
@Slf4j
public class CatalogEventHandler implements EventHandler {

        private static final String CREATE_EVENT = "CatalogCreateEvent";
        private static final String DELETE_EVENT = "CatalogDeleteEvent";
        private static final String STATE_CHANGE_EVENT = "CatalogStateChangeEvent";

        private static final List<String> SUPPORTED_EVENT_TYPES = List.of(CREATE_EVENT, DELETE_EVENT, STATE_CHANGE_EVENT);

        private final CatalogApiClient catalogApiClient;
        private final ObjectMapper objectMapper;
        private final RainbowMapper rainbowMapper;

        @Override
        public boolean isEventTypeSupported(String eventType) {
                return SUPPORTED_EVENT_TYPES.contains(eventType);
        }

        @Override
        public Mono<HttpResponse<?>> handleEvent(String eventType, Map<String, Object> event) {
                return switch (eventType) {
                        case CREATE_EVENT -> handleCatalogCreation(event);
                        case STATE_CHANGE_EVENT -> handleCatalogStateChange(event);
                        case DELETE_EVENT -> handleCatalogDeletion(event);
                        default -> throw new IllegalArgumentException("Even type %s is not supported.".formatted(eventType));
                };
        }

        private Mono<HttpResponse<?>> handleCatalogCreation(Map<String, Object> createEvent) {
                CatalogCreateEventVO catalogCreateEventVO = objectMapper.convertValue(createEvent, CatalogCreateEventVO.class);
                CatalogVO catalogVO = Optional.ofNullable(catalogCreateEventVO.getEvent())
                                .map(CatalogCreateEventPayloadVO::getCatalog)
                                .orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));
                NewCatalogVO rainbowCatalog = rainbowMapper.map(catalogVO);
                return catalogApiClient.createCatalog(rainbowCatalog)
                                .onErrorMap(t -> new IllegalArgumentException("Was not able create the catalog %s".formatted(rainbowCatalog), t))
                                .map(HttpResponse::ok);
        }


        private Mono<HttpResponse<?>> handleCatalogStateChange(Map<String, Object> createEvent) {
                CatalogStateChangeEventVO catalogStateChangeEventVO = objectMapper.convertValue(createEvent, CatalogStateChangeEventVO.class);
                CatalogVO catalogVO = Optional.ofNullable(catalogStateChangeEventVO.getEvent())
                                .map(CatalogStateChangeEventPayloadVO::getCatalog)
                                .orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));

                return catalogApiClient.updateCatalogById(catalogVO.getId(), rainbowMapper.map(catalogVO)).map(res -> {
                        if (res.getStatus().getCode() >= 200 && res.getStatus().getCode() < 300) {
                                return HttpResponse.noContent();
                        }
                        return HttpResponse.status(HttpStatus.BAD_GATEWAY);
                });
        }

        private Mono<HttpResponse<?>> handleCatalogDeletion(Map<String, Object> deleteEvent) {
                CatalogDeleteEventVO catalogDeleteEventVO = objectMapper.convertValue(deleteEvent, CatalogDeleteEventVO.class);
                CatalogVO catalogVO = Optional.ofNullable(catalogDeleteEventVO.getEvent())
                                .map(CatalogDeleteEventPayloadVO::getCatalog)
                                .orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));
                return catalogApiClient.deleteCatalogById(catalogVO.getId()).map(res -> {
                        if (res.getStatus().getCode() >= 200 && res.getStatus().getCode() < 300) {
                                return HttpResponse.noContent();
                        }
                        return HttpResponse.status(HttpStatus.BAD_GATEWAY);
                });
        }
}

1	package org.fiware.iam.tmforum.handlers;
2
3	import com.fasterxml.jackson.databind.ObjectMapper;
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.RainbowMapper;
10	import org.fiware.iam.tmforum.productcatalog.model.*;
11	import org.fiware.rainbow.api.CatalogApiClient;
12	import org.fiware.rainbow.model.NewCatalogVO;
13	import reactor.core.publisher.Mono;
14
15	import java.util.List;
16	import java.util.Map;
17	import java.util.Optional;
18
19	@RequiredArgsConstructor
20	@Singleton
NEW 21	@Slf4j	×
22	public class CatalogEventHandler implements EventHandler {
23
24	private static final String CREATE_EVENT = "CatalogCreateEvent";
25	private static final String DELETE_EVENT = "CatalogDeleteEvent";
26	private static final String STATE_CHANGE_EVENT = "CatalogStateChangeEvent";
27
NEW 28	private static final List<String> SUPPORTED_EVENT_TYPES = List.of(CREATE_EVENT, DELETE_EVENT, STATE_CHANGE_EVENT);	×
29
30	private final CatalogApiClient catalogApiClient;
31	private final ObjectMapper objectMapper;
32	private final RainbowMapper rainbowMapper;
33
34	@Override
35	public boolean isEventTypeSupported(String eventType) {
NEW 36	return SUPPORTED_EVENT_TYPES.contains(eventType);	×
37	}
38
39	@Override
40	public Mono<HttpResponse<?>> handleEvent(String eventType, Map<String, Object> event) {
NEW 41	return switch (eventType) {	×
NEW 42	case CREATE_EVENT -> handleCatalogCreation(event);	×
NEW 43	case STATE_CHANGE_EVENT -> handleCatalogStateChange(event);	×
NEW 44	case DELETE_EVENT -> handleCatalogDeletion(event);	×
NEW 45	default -> throw new IllegalArgumentException("Even type %s is not supported.".formatted(eventType));	×
46	};
47	}
48
49	private Mono<HttpResponse<?>> handleCatalogCreation(Map<String, Object> createEvent) {
NEW 50	CatalogCreateEventVO catalogCreateEventVO = objectMapper.convertValue(createEvent, CatalogCreateEventVO.class);	×
NEW 51	CatalogVO catalogVO = Optional.ofNullable(catalogCreateEventVO.getEvent())	×
NEW 52	.map(CatalogCreateEventPayloadVO::getCatalog)	×
NEW 53	.orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));	×
NEW 54	NewCatalogVO rainbowCatalog = rainbowMapper.map(catalogVO);	×
NEW 55	return catalogApiClient.createCatalog(rainbowCatalog)	×
NEW 56	.onErrorMap(t -> new IllegalArgumentException("Was not able create the catalog %s".formatted(rainbowCatalog), t))	×
NEW 57	.map(HttpResponse::ok);	×
58	}
59
60
61	private Mono<HttpResponse<?>> handleCatalogStateChange(Map<String, Object> createEvent) {
NEW 62	CatalogStateChangeEventVO catalogStateChangeEventVO = objectMapper.convertValue(createEvent, CatalogStateChangeEventVO.class);	×
NEW 63	CatalogVO catalogVO = Optional.ofNullable(catalogStateChangeEventVO.getEvent())	×
NEW 64	.map(CatalogStateChangeEventPayloadVO::getCatalog)	×
NEW 65	.orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));	×
66
NEW 67	return catalogApiClient.updateCatalogById(catalogVO.getId(), rainbowMapper.map(catalogVO)).map(res -> {	×
NEW 68	if (res.getStatus().getCode() >= 200 && res.getStatus().getCode() < 300) {	×
NEW 69	return HttpResponse.noContent();	×
70	}
NEW 71	return HttpResponse.status(HttpStatus.BAD_GATEWAY);	×
72	});
73	}
74
75	private Mono<HttpResponse<?>> handleCatalogDeletion(Map<String, Object> deleteEvent) {
NEW 76	CatalogDeleteEventVO catalogDeleteEventVO = objectMapper.convertValue(deleteEvent, CatalogDeleteEventVO.class);	×
NEW 77	CatalogVO catalogVO = Optional.ofNullable(catalogDeleteEventVO.getEvent())	×
NEW 78	.map(CatalogDeleteEventPayloadVO::getCatalog)	×
NEW 79	.orElseThrow(() -> new IllegalArgumentException("The event does not contain a catalog."));	×
NEW 80	return catalogApiClient.deleteCatalogById(catalogVO.getId()).map(res -> {	×
NEW 81	if (res.getStatus().getCode() >= 200 && res.getStatus().getCode() < 300) {	×
NEW 82	return HttpResponse.noContent();	×
83	}
NEW 84	return HttpResponse.status(HttpStatus.BAD_GATEWAY);	×
85	});
86	}
87	}

FIWARE / contract-management / #26

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