Merge branch 'develop' into 'range-interval-type-validation' (7a3cc939) · Commits · OSL / code / org.etsi.osl.tmf.api

pom.xml

+8 −16

Original line number	Diff line number	Diff line
		@@ -281,21 +281,6 @@
		<artifactId>spring-security-test</artifactId>
		<scope>test</scope>
		</dependency>
		<dependency>
		<groupId>org.junit.jupiter</groupId>
		<artifactId>junit-jupiter-engine</artifactId>
		<scope>test</scope>
		</dependency>
		<dependency>
		<groupId>org.junit.platform</groupId>
		<artifactId>junit-platform-commons</artifactId>
		<scope>test</scope>
		</dependency>
		<dependency>
		<groupId>org.junit.platform</groupId>
		<artifactId>junit-platform-runner</artifactId>
		<scope>test</scope>
		</dependency>
		<dependency>
		<groupId>org.mockito</groupId>
		<artifactId>mockito-inline</artifactId>
		@@ -448,13 +433,17 @@
		<!-- Disable parallel execution -->
		<parallel>none</parallel>
		<runOrder>alphabetical</runOrder>
		<forkCount>1</forkCount>
		<forkCount>3</forkCount>
		<reuseForks>true</reuseForks>
		</configuration>
		</plugin>
		<plugin>
		<groupId>org.jacoco</groupId>
		<artifactId>jacoco-maven-plugin</artifactId>
		<version>0.8.12</version>
		<configuration>
		<skip>true</skip>
		</configuration>
		<executions>
		<execution>
		<goals>
		@@ -475,6 +464,9 @@
		<groupId>org.jacoco</groupId>
		<artifactId>jacoco-maven-plugin</artifactId>
		<version>0.8.12</version>
		<configuration>
		<skip>true</skip>
		</configuration>
		<executions>
		<execution>
		<goals>

src/main/java/org/etsi/osl/tmf/pcm620/api/HubApi.java

+27 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ import org.springframework.web.bind.annotation.PathVariable;
		import org.springframework.web.bind.annotation.RequestBody;
		import org.springframework.web.bind.annotation.RequestMapping;
		import org.springframework.web.bind.annotation.RequestMethod;
		import java.util.List;
		import io.swagger.v3.oas.annotations.Operation;
		import io.swagger.v3.oas.annotations.Parameter;
		import io.swagger.v3.oas.annotations.responses.ApiResponse;
		@@ -116,4 +117,30 @@ public interface HubApi {
		return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);
		}

		@Operation(summary = "Get all registered listeners", operationId = "getListeners", description = "Retrieves all registered event subscriptions", tags={ "events subscription", })
		@ApiResponses(value = {
		@ApiResponse(responseCode = "200", description = "Success" ),
		@ApiResponse(responseCode = "400", description = "Bad Request" ),
		@ApiResponse(responseCode = "401", description = "Unauthorized" ),
		@ApiResponse(responseCode = "403", description = "Forbidden" ),
		@ApiResponse(responseCode = "500", description = "Internal Server Error" ) })
		@RequestMapping(value = "/hub",
		produces = { "application/json;charset=utf-8" },
		method = RequestMethod.GET)
		default ResponseEntity<List<EventSubscription>> getListeners() {
		if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
		if (getAcceptHeader().get().contains("application/json")) {
		try {
		return new ResponseEntity<>(getObjectMapper().get().readValue("[ { \"query\" : \"query\", \"callback\" : \"callback\", \"id\" : \"id\"} ]", List.class), HttpStatus.NOT_IMPLEMENTED);
		} catch (IOException e) {
		log.error("Couldn't serialize response for content type application/json", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}
		} else {
		log.warn("ObjectMapper or HttpServletRequest not configured in default HubApi interface so no example is generated");
		}
		return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);
		}

		}

src/main/java/org/etsi/osl/tmf/pcm620/api/HubApiController.java

+68 −1

Original line number	Diff line number	Diff line
		@@ -19,24 +19,43 @@
		*/
		package org.etsi.osl.tmf.pcm620.api;

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

		import com.fasterxml.jackson.databind.ObjectMapper;

		import org.etsi.osl.tmf.pcm620.model.EventSubscription;
		import org.etsi.osl.tmf.pcm620.model.EventSubscriptionInput;
		import org.etsi.osl.tmf.pcm620.reposervices.EventSubscriptionRepoService;
		import org.slf4j.Logger;
		import org.slf4j.LoggerFactory;
		import org.springframework.beans.factory.annotation.Autowired;
		import org.springframework.http.HttpStatus;
		import org.springframework.http.ResponseEntity;
		import org.springframework.security.access.prepost.PreAuthorize;
		import org.springframework.stereotype.Controller;
		import org.springframework.web.bind.annotation.PathVariable;
		import org.springframework.web.bind.annotation.RequestBody;
		import org.springframework.web.bind.annotation.RequestMapping;
		import org.springframework.web.bind.annotation.RequestMethod;

		import io.swagger.v3.oas.annotations.Parameter;
		import jakarta.servlet.http.HttpServletRequest;
		import jakarta.validation.Valid;
		@jakarta.annotation.Generated(value = "io.swagger.codegen.languages.SpringCodegen", date = "2019-10-19T00:15:57.249+03:00")

		@Controller("HubApiController620")
		@RequestMapping("/productCatalogManagement/v4/")
		public class HubApiController implements HubApi {

		private static final Logger log = LoggerFactory.getLogger(HubApiController.class);

		private final ObjectMapper objectMapper;

		private final HttpServletRequest request;

		@Autowired
		EventSubscriptionRepoService eventSubscriptionRepoService;

		@org.springframework.beans.factory.annotation.Autowired
		public HubApiController(ObjectMapper objectMapper, HttpServletRequest request) {
		this.objectMapper = objectMapper;
		@@ -53,4 +72,52 @@ public class HubApiController implements HubApi {
		return Optional.ofNullable(request);
		}

		/*
		* to register another OSL for example use "callback": "http://localhost:13082/tmf-api/productCatalogManagement/v4/"
		*/
		@Override
		@PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")
		public ResponseEntity<EventSubscription> registerListener(@Parameter(description = "Data containing the callback endpoint to deliver the information", required = true) @Valid @RequestBody EventSubscriptionInput data) {
		try {
		EventSubscription eventSubscription = eventSubscriptionRepoService.addEventSubscription(data);
		return new ResponseEntity<>(eventSubscription, HttpStatus.CREATED);
		} catch (IllegalArgumentException e) {
		log.error("Invalid input for listener registration: {}", e.getMessage());
		return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
		} catch (Exception e) {
		log.error("Error registering listener", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		@PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")
		@RequestMapping(value = "/hub/{id}", method = RequestMethod.DELETE, produces = { "application/json;charset=utf-8" })
		public ResponseEntity<Void> unregisterListener(@Parameter(description = "The id of the registered listener", required = true) @PathVariable("id") String id) {
		try {
		EventSubscription existing = eventSubscriptionRepoService.findById(id);
		if (existing == null) {
		return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}

		eventSubscriptionRepoService.deleteById(id);
		return new ResponseEntity<>(HttpStatus.NO_CONTENT);
		} catch (Exception e) {
		log.error("Error unregistering listener with id: " + id, e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		@PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")
		public ResponseEntity<List<EventSubscription>> getListeners() {
		try {
		List<EventSubscription> eventSubscriptions = eventSubscriptionRepoService.findAll();
		return new ResponseEntity<>(eventSubscriptions, HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error retrieving listeners", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		}

src/main/java/org/etsi/osl/tmf/pcm620/api/ListenerApiController.java

+205 −1

Original line number	Diff line number	Diff line
		@@ -22,17 +22,41 @@ package org.etsi.osl.tmf.pcm620.api;
		import java.util.Optional;

		import com.fasterxml.jackson.databind.ObjectMapper;

		import org.etsi.osl.tmf.pcm620.model.CatalogBatchEvent;
		import org.etsi.osl.tmf.pcm620.model.CatalogCreateEvent;
		import org.etsi.osl.tmf.pcm620.model.CatalogDeleteEvent;
		import org.etsi.osl.tmf.pcm620.model.CategoryCreateEvent;
		import org.etsi.osl.tmf.pcm620.model.CategoryDeleteEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingAttributeValueChangeEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingCreateEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingDeleteEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceAttributeValueChangeEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceCreateEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceDeleteEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceStateChangeEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductOfferingStateChangeEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductSpecificationCreateEvent;
		import org.etsi.osl.tmf.pcm620.model.ProductSpecificationDeleteEvent;
		import org.etsi.osl.tmf.pcm620.model.EventSubscription;
		import org.slf4j.Logger;
		import org.slf4j.LoggerFactory;
		import org.springframework.http.HttpStatus;
		import org.springframework.http.ResponseEntity;
		import org.springframework.stereotype.Controller;
		import org.springframework.web.bind.annotation.RequestBody;
		import org.springframework.web.bind.annotation.RequestMapping;

		import io.swagger.v3.oas.annotations.Parameter;
		import jakarta.servlet.http.HttpServletRequest;
		import jakarta.validation.Valid;
		@jakarta.annotation.Generated(value = "io.swagger.codegen.languages.SpringCodegen", date = "2019-10-19T00:15:57.249+03:00")

		@Controller("ListenerApiController620")
		@RequestMapping("/productCatalogManagement/v4/")
		public class ListenerApiController implements ListenerApi {

		private static final Logger log = LoggerFactory.getLogger(ListenerApiController.class);

		private final ObjectMapper objectMapper;

		private final HttpServletRequest request;
		@@ -53,4 +77,184 @@ public class ListenerApiController implements ListenerApi {
		return Optional.ofNullable(request);
		}

		@Override
		public ResponseEntity<EventSubscription> listenToCatalogBatchEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogBatchEvent data) {
		try {
		log.info("Received CatalogBatchEvent: {}", data.getEventId());
		log.debug("CatalogBatchEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing CatalogBatchEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToCatalogCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogCreateEvent data) {
		try {
		log.info("Received CatalogCreateEvent: {}", data.getEventId());
		log.debug("CatalogCreateEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing CatalogCreateEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToCatalogDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogDeleteEvent data) {
		try {
		log.info("Received CatalogDeleteEvent: {}", data.getEventId());
		log.debug("CatalogDeleteEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing CatalogDeleteEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToCategoryCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CategoryCreateEvent data) {
		try {
		log.info("Received CategoryCreateEvent: {}", data.getEventId());
		log.debug("CategoryCreateEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing CategoryCreateEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToCategoryDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CategoryDeleteEvent data) {
		try {
		log.info("Received CategoryDeleteEvent: {}", data.getEventId());
		log.debug("CategoryDeleteEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing CategoryDeleteEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingAttributeValueChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingAttributeValueChangeEvent data) {
		try {
		log.info("Received ProductOfferingAttributeValueChangeEvent: {}", data.getEventId());
		log.debug("ProductOfferingAttributeValueChangeEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingAttributeValueChangeEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingCreateEvent data) {
		try {
		log.info("Received ProductOfferingCreateEvent: {}", data.getEventId());
		log.debug("ProductOfferingCreateEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingCreateEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingDeleteEvent data) {
		try {
		log.info("Received ProductOfferingDeleteEvent: {}", data.getEventId());
		log.debug("ProductOfferingDeleteEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingDeleteEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingPriceAttributeValueChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceAttributeValueChangeEvent data) {
		try {
		log.info("Received ProductOfferingPriceAttributeValueChangeEvent: {}", data.getEventId());
		log.debug("ProductOfferingPriceAttributeValueChangeEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingPriceAttributeValueChangeEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingPriceCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceCreateEvent data) {
		try {
		log.info("Received ProductOfferingPriceCreateEvent: {}", data.getEventId());
		log.debug("ProductOfferingPriceCreateEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingPriceCreateEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingPriceDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceDeleteEvent data) {
		try {
		log.info("Received ProductOfferingPriceDeleteEvent: {}", data.getEventId());
		log.debug("ProductOfferingPriceDeleteEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingPriceDeleteEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingPriceStateChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceStateChangeEvent data) {
		try {
		log.info("Received ProductOfferingPriceStateChangeEvent: {}", data.getEventId());
		log.debug("ProductOfferingPriceStateChangeEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingPriceStateChangeEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductOfferingStateChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingStateChangeEvent data) {
		try {
		log.info("Received ProductOfferingStateChangeEvent: {}", data.getEventId());
		log.debug("ProductOfferingStateChangeEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductOfferingStateChangeEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductSpecificationCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductSpecificationCreateEvent data) {
		try {
		log.info("Received ProductSpecificationCreateEvent: {}", data.getEventId());
		log.debug("ProductSpecificationCreateEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductSpecificationCreateEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		@Override
		public ResponseEntity<EventSubscription> listenToProductSpecificationDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductSpecificationDeleteEvent data) {
		try {
		log.info("Received ProductSpecificationDeleteEvent: {}", data.getEventId());
		log.debug("ProductSpecificationDeleteEvent details: {}", data);
		return new ResponseEntity<>(HttpStatus.OK);
		} catch (Exception e) {
		log.error("Error processing ProductSpecificationDeleteEvent", e);
		return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
		}
		}

		}

src/main/java/org/etsi/osl/tmf/pcm620/api/ProductCatalogApiRouteBuilderEvents.java

0 → 100644

+189 −0

File added.

Preview size limit exceeded, changes collapsed.