feat: introduce changes reflecting ResourceDTO and ResourceResponse introduced (8a3ebaa8) · Commits · OSL / MDG HypO / code / org.etsi.osl.hypo.api / org.etsi.osl.hypo.api.tmf

src/main/java/org/etsi/osl/hypo/api/tmf/resources/catalog/api/model/resource/response/ResourceCandidateResponseDTO.java

+0 −5

Original line number	Diff line number	Diff line
		@@ -3,7 +3,6 @@ package org.etsi.osl.hypo.api.tmf.resources.catalog.api.model.resource.response;
		import com.fasterxml.jackson.annotation.JsonInclude;
		import com.fasterxml.jackson.annotation.JsonProperty;
		import com.fasterxml.jackson.annotation.JsonPropertyOrder;
		import java.util.UUID;
		import lombok.Data;
		import lombok.EqualsAndHashCode;
		import org.etsi.osl.hypo.api.tmf.common.schema.ValidFor;
		@@ -23,10 +22,6 @@ import org.etsi.osl.hypo.api.tmf.resources.catalog.api.model.resource.base.BaseF
		@JsonInclude(JsonInclude.Include.NON_NULL)
		@EqualsAndHashCode(callSuper = true)
		public class ResourceCandidateResponseDTO extends BaseFieldsDTO {

		@JsonProperty("id")
		private UUID id;

		@JsonProperty("href")
		private String href;

src/main/java/org/etsi/osl/hypo/api/tmf/resources/inventory/api/mapper/ResourceMapper.java

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		package org.etsi.osl.hypo.api.tmf.resources.inventory.api.mapper;

		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceDTO;
		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceResponse;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.schema.Resource;
		import org.mapstruct.BeanMapping;
		import org.mapstruct.InjectionStrategy;
		import org.mapstruct.Mapper;
		import org.mapstruct.Mapping;
		import org.mapstruct.MappingTarget;
		import org.mapstruct.NullValuePropertyMappingStrategy;
		import org.mapstruct.SubclassExhaustiveStrategy;

		@Mapper(
		componentModel = "cdi",
		injectionStrategy = InjectionStrategy.CONSTRUCTOR,
		subclassExhaustiveStrategy = SubclassExhaustiveStrategy.RUNTIME_EXCEPTION)
		public interface ResourceMapper {

		@Mapping(target = "id", ignore = true)
		Resource resourceRequestToEntity(ResourceDTO resourceDTO);

		ResourceResponse resourceEntityToResponse(Resource resource);

		ResourceDTO resourceResponseToDto(ResourceResponse resourceResponse);

		Resource resourceResponseToEntity(ResourceResponse resourceResponse);

		@Mapping(target = "entityId", ignore = true)
		@Mapping(target = "resourceSpecification.entityId", ignore = true)
		@Mapping(target = "relatedParty", ignore = true)
		@Mapping(target = "resourceSpecification.resourceRelationship.resource.entityId", ignore = true)
		@BeanMapping(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
		void updateResource(Resource newResource, @MappingTarget Resource oldResource);
		}

src/main/java/org/etsi/osl/hypo/api/tmf/resources/inventory/api/rest/ResourceInventoryResource.java

+44 −35

Original line number	Diff line number	Diff line
		@@ -5,7 +5,6 @@ import static org.etsi.osl.hypo.api.tmf.resources.inventory.api.rest.ResourceInv

		import io.quarkus.security.Authenticated;
		import jakarta.annotation.security.PermitAll;
		import jakarta.validation.Valid;
		import jakarta.ws.rs.Consumes;
		import jakarta.ws.rs.DELETE;
		import jakarta.ws.rs.GET;
		@@ -26,9 +25,10 @@ import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
		import org.eclipse.microprofile.openapi.annotations.tags.Tag;
		import org.etsi.osl.hypo.api.tmf.common.api.services.UtilService;
		import org.etsi.osl.hypo.api.tmf.common.model.ErrorMessage;
		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceDTO;
		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceResponse;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.api.services.ResourceInventoryService;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.schema.ApplicationProperties;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.schema.Resource;
		import org.jboss.logging.Logger;
		import org.jboss.resteasy.reactive.RestPath;
		import org.jboss.resteasy.reactive.RestQuery;
		@@ -58,13 +58,15 @@ public class ResourceInventoryResource {

		@POST
		@Operation(
		summary = "Creates a valid ResourceInventory",
		description = "This operation creates a ResourceInventory entity.")
		summary = "Creates a valid Resource",
		description = "This operation creates a Resource entity.")
		@APIResponse(
		responseCode = "201",
		description = "Created",
		content =
		@Content(mediaType = APPLICATION_JSON, schema = @Schema(implementation = Resource.class)))
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ResourceResponse.class)))
		@APIResponse(responseCode = "400", description = "Bad Request")
		@APIResponse(
		responseCode = "500",
		@@ -73,27 +75,31 @@ public class ResourceInventoryResource {
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ErrorMessage.class)))
		public Response createResourceInventory(@Valid Resource resourceInventoryRequest) {
		logger.infof("CreateResourceInventory Request : %s", resourceInventoryRequest.toString());
		Resource createdResourceInventory =
		public Response createResourceInventory(ResourceDTO resourceInventoryRequest) {
		logger.infof("POST Resource Request with name: %s", resourceInventoryRequest.getName());
		logger.debugf("POST Resource Request : %s", resourceInventoryRequest.toString());
		ResourceResponse resourceResponse =
		resourceInventoryService.createResource(resourceInventoryRequest, uriInfo);
		logger.infof("CreateResourceInventory Response : %s", createdResourceInventory.toString());
		return Response.ok(createdResourceInventory).status(201).build();
		logger.debugf("POST Resource Response : %s", resourceResponse.toString());
		logger.infof(
		"POST Resource Response with id :%s and name: %s",
		resourceResponse.getId(), resourceResponse.getName());
		return Response.ok(resourceResponse).status(201).build();
		}

		@GET
		@PermitAll
		@Operation(
		summary = "List or find all Resource Inventory objects",
		description = "This operation list or find ResourceInventory entities.")
		description = "This operation list or find Resource entities.")
		@APIResponse(
		responseCode = "200",
		description = "Success",
		content =
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = Resource.class, type = SchemaType.ARRAY)))
		public Response getAll(@RestQuery String fields, @RestQuery int limit, @Context UriInfo uriInfo) {
		schema = @Schema(implementation = ResourceResponse.class, type = SchemaType.ARRAY)))
		public Response getAll(@RestQuery String fields, @Context UriInfo uriInfo) {
		Map<String, String> criteriaParams = UtilService.getRequestedCriteriaForFiltering(uriInfo);
		return Response.ok(resourceInventoryService.getByCriteria(fields, criteriaParams)).build();
		}
		@@ -102,14 +108,16 @@ public class ResourceInventoryResource {
		@PermitAll
		@Path("/{id}")
		@Operation(
		summary = "Retrieves a ResourceInventory by ID",
		summary = "Retrieves a Resource by ID",
		description =
		"This operation retrieves a ResourceInventory entity. Attribute selection is enabled for all first level attributes.")
		"This operation retrieves a Resource entity. Attribute selection is enabled for all first level attributes.")
		@APIResponse(
		responseCode = "200",
		description = "Success",
		content =
		@Content(mediaType = APPLICATION_JSON, schema = @Schema(implementation = Resource.class)))
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ResourceResponse.class)))
		@APIResponse(
		responseCode = "404",
		description = "Not Found",
		@@ -118,25 +126,28 @@ public class ResourceInventoryResource {
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ErrorMessage.class)))
		public Response getById(@RestPath String id, @RestQuery String fields, @Context UriInfo uriInfo) {
		logger.infof("Get Request: service specification with id : %s", id);
		logger.infof("GET Request: resource with id : %s", id);

		Map<String, String> criteriaParams = UtilService.getRequestedCriteriaForFiltering(uriInfo);

		Resource retrievedResourceInventory =
		ResourceResponse retrievedResourceInventory =
		resourceInventoryService.getByIdAndCriteria(id, fields, criteriaParams);

		logger.infof("Get Response for id %s: %s", id, retrievedResourceInventory);
		logger.debugf("Get Response for id %s: %s", id, retrievedResourceInventory);
		logger.infof("GET Request success: resource with id : %s", id);
		return Response.ok(retrievedResourceInventory).build();
		}

		@PATCH
		@Path("/{id}")
		@Operation(summary = "Updates partially a ResourceInventory")
		@Operation(summary = "Updates partially a Resource")
		@APIResponse(
		responseCode = "200",
		description = "Updated",
		content =
		@Content(mediaType = APPLICATION_JSON, schema = @Schema(implementation = Resource.class)))
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ResourceResponse.class)))
		@APIResponse(
		responseCode = "400",
		description = "Bad Request",
		@@ -158,23 +169,21 @@ public class ResourceInventoryResource {
		@Content(
		mediaType = APPLICATION_JSON,
		schema = @Schema(implementation = ErrorMessage.class)))
		public Response update(@Valid Resource resourceInventoryRequest, @RestPath String id) {
		logger.infof("Update Request for service order with id : %s", id);
		logger.infof("Update Request Order Body : %s", resourceInventoryRequest.toString());
		return Response.ok(resourceInventoryService.updateResource(id, resourceInventoryRequest))
		.build();
		public Response update(ResourceDTO resourceDTO, @RestPath String id) {
		logger.infof("PATCH Resource Request for resource with id : %s", id);
		logger.debugf("PATCH Resource Order Body : %s", resourceDTO.toString());
		ResourceResponse resourceResponse = resourceInventoryService.updateResource(id, resourceDTO);
		logger.infof("PATCH Resource Request SUCCESS for resource with id : %s", id);
		logger.debugf("PATCH Resource Response Body : %s", resourceResponse.toString());
		return Response.ok(resourceResponse).build();
		}

		@DELETE
		@Path("/{id}")
		@Operation(
		summary = "Deletes a ResourceInventory by ID",
		description = "This operation deletes a ResourceInventory entity.")
		@APIResponse(
		responseCode = "200",
		description = "Deleted",
		content =
		@Content(mediaType = APPLICATION_JSON, schema = @Schema(implementation = Resource.class)))
		summary = "Deletes a Resource by ID",
		description = "This operation deletes a Resource entity.")
		@APIResponse(responseCode = "204", description = "Deleted")
		@APIResponse(
		responseCode = "404",
		description = "Not Found",
		@@ -184,8 +193,8 @@ public class ResourceInventoryResource {
		schema = @Schema(implementation = ErrorMessage.class)))
		public Response delete(@RestPath String id) {
		logger.infof("Delete Request for service specification with id : %s", id);
		Resource deletedResourceInventory = resourceInventoryService.deleteResource(id);
		resourceInventoryService.deleteResourceById(id);
		logger.infof("Successful Delete operation for service specification with id : %s", id);
		return Response.ok(deletedResourceInventory).build();
		return Response.noContent().build();
		}
		}

src/main/java/org/etsi/osl/hypo/api/tmf/resources/inventory/api/services/ResourceInventoryService.java

+53 −53

Original line number	Diff line number	Diff line
		@@ -17,15 +17,16 @@ import java.util.Set;
		import java.util.stream.Collectors;
		import org.apache.commons.collections4.CollectionUtils;
		import org.etsi.osl.hypo.api.tmf.common.api.helpers.SystemClockHelper;
		import org.etsi.osl.hypo.api.tmf.common.api.mapper.UpdateMapper;
		import org.etsi.osl.hypo.api.tmf.common.api.repository.RelatedPartyRepository;
		import org.etsi.osl.hypo.api.tmf.common.api.services.RelatedPartyService;
		import org.etsi.osl.hypo.api.tmf.common.api.services.UtilService;
		import org.etsi.osl.hypo.api.tmf.common.exception.DuplicateKeyException;
		import org.etsi.osl.hypo.api.tmf.common.exception.ServiceNotFoundException;
		import org.etsi.osl.hypo.api.tmf.common.model.BaseEntity;
		import org.etsi.osl.hypo.api.tmf.common.schema.RelatedPartyEntity;
		import org.etsi.osl.hypo.api.tmf.common.schema.ValueEntity;
		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceDTO;
		import org.etsi.osl.hypo.api.tmf.resources.common.model.ResourceResponse;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.api.mapper.ResourceMapper;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.api.repository.ResourceInventoryRepository;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.schema.Characteristic;
		import org.etsi.osl.hypo.api.tmf.resources.inventory.schema.Resource;
		@@ -42,24 +43,56 @@ import org.jboss.logging.Logger;
		public class ResourceInventoryService {

		private final ResourceInventoryRepository resourceInventoryRepository;
		private final UpdateMapper updateMapper;
		private final ResourceMapper resourceMapper;
		private final RelatedPartyService relatedPartyService;
		private final RelatedPartyRepository relatedPartyRepository;

		private static final Logger logger = Logger.getLogger(ResourceInventoryService.class);
		private static final String INVENTORY_WITH_ID = "Resource Inventory with id ";

		public ResourceInventoryService(
		ResourceInventoryRepository resourceInventoryRepository,
		UpdateMapper updateMapper,
		ResourceMapper resourceMapper,
		RelatedPartyService relatedPartyService,
		RelatedPartyRepository relatedPartyRepository) {
		this.resourceInventoryRepository = resourceInventoryRepository;
		this.updateMapper = updateMapper;
		this.resourceMapper = resourceMapper;
		this.relatedPartyService = relatedPartyService;
		this.relatedPartyRepository = relatedPartyRepository;
		}

		@Transactional
		public ResourceResponse createResource(ResourceDTO resourceDTO, UriInfo uriInfo) {
		Resource resource = resourceMapper.resourceRequestToEntity(resourceDTO);
		createResourceEntity(uriInfo, resource);
		return resourceMapper.resourceEntityToResponse(resource);
		}

		private void createResourceEntity(UriInfo uriInfo, Resource resource) {
		findRelatedPartyAndAddItToResource(resource);
		if (uriInfo != null) {
		resource.setUri(uriInfo.getAbsolutePath());
		}
		resourceInventoryRepository.persist(resource);
		}

		@Transactional
		public ResourceResponse updateResource(String id, ResourceDTO resourceDTO) {
		Resource newResource = resourceMapper.resourceRequestToEntity(resourceDTO);
		Resource oldResource = getById(id);
		resourceMapper.updateResource(newResource, oldResource);
		return resourceMapper.resourceEntityToResponse(oldResource);
		}

		@Transactional
		public void deleteResourceById(String id) {
		Resource resource = getById(id);
		deleteResource(resource);
		}

		public void deleteResource(Resource resource) {
		resourceInventoryRepository.delete(resource);
		}

		@Transactional
		public List<Resource> findAll() {
		return resourceInventoryRepository.findAll().list();
		@@ -79,7 +112,7 @@ public class ResourceInventoryService {
		}

		@Transactional
		public Resource getByIdAndCriteria(String id, String fields, Map<String, String> params) {
		public ResourceResponse getByIdAndCriteria(String id, String fields, Map<String, String> params) {
		List<Resource> resources = resourceInventoryRepository.findWithCriteriaQuery(id, params, null);
		if (resources.isEmpty()) {
		String notFoundMessage =
		@@ -87,46 +120,27 @@ public class ResourceInventoryService {
		throw new ServiceNotFoundException(notFoundMessage);
		}

		return UtilService.filterFields(resources.get(0), fields);
		Resource resource = resources.get(0);
		ResourceResponse resourceResponse = resourceMapper.resourceEntityToResponse(resource);
		return UtilService.filterFields(resourceResponse, fields);
		}

		@Transactional
		public List<Resource> getByCriteria(String fields, Map<String, String> params) {
		public List<ResourceResponse> getByCriteria(String fields, Map<String, String> params) {
		List<Resource> resources =
		resourceInventoryRepository.findWithCriteriaQuery(null, params, null);
		return UtilService.getFilteredList(resources, fields);
		return UtilService.getFilteredList(resources, fields).stream()
		.map(resourceMapper::resourceEntityToResponse)
		.toList();
		}

		@Transactional
		public Resource deleteResource(String id) {
		Resource resource = getById(id);

		resource
		.getRelatedParty()
		.forEach(
		relatedPartyEntity -> {
		relatedPartyEntity.getResources().remove(resource);
		relatedPartyRepository.persist(relatedPartyEntity);
		});

		resource.getRelatedParty().clear();
		resourceInventoryRepository.delete(resource);
		return resource;
		public Set<Resource> getResourcesSet(Set<String> ids) {
		return resourceInventoryRepository.findByIdsSet(ids);
		}

		@Transactional
		public Resource createResource(Resource resource, UriInfo uriInfo) {
		checkIfIdExists(resource.getId());
		findRelatedPartyAndAddItToResource(resource);
		if (uriInfo != null) {
		resource.setUri(uriInfo.getAbsolutePath());
		}
		resourceInventoryRepository.persist(resource);
		return resource;
		}

		public Set<Resource> getResourcesSet(Set<String> ids) {
		return resourceInventoryRepository.findByIdsSet(ids);
		public Resource createResource(ResourceDashboardData resourceDashboardData, Service service) {
		return this.createResourceForService(resourceDashboardData, service);
		}

		public Resource createResourceForService(
		@@ -157,8 +171,8 @@ public class ResourceInventoryService {
		relatedPartyRepository.findByIdsSet(stringList);
		resource.setRelatedParty(retrievedRelatedParty);
		}

		return createResource(resource, null);
		createResourceEntity(null, resource);
		return resource;
		}

		private static Set<Characteristic> getCharacteristics(
		@@ -213,20 +227,6 @@ public class ResourceInventoryService {
		}
		}

		@Transactional
		public Resource updateResource(String id, Resource newResource) {
		Resource oldResource = getById(id);
		Resource resource = updateMapper.updateResource(newResource, oldResource);
		resourceInventoryRepository.persist(resource);
		return resource;
		}

		private void checkIfIdExists(String id) {
		if (idExists(id)) {
		throw new DuplicateKeyException(INVENTORY_WITH_ID + id + " already exists");
		}
		}

		public boolean idExists(String id) {
		return resourceInventoryRepository.findById(id).isPresent();
		}

src/main/java/org/etsi/osl/hypo/api/tmf/services/common/ServiceOrderAndServiceRepositories.java

+25 −31

Original line number	Diff line number	Diff line
		@@ -624,9 +624,9 @@ public class ServiceOrderAndServiceRepositories {
		@Transactional
		public void createResourceWithDashboardData(ResourceDashboardData resourceDashboardData) {
		String serviceId = resourceDashboardData.getServiceId().toString();
		serviceHelper
		.findServiceById(serviceId)
		.ifPresentOrElse(
		Optional<Service> serviceById = serviceHelper.findServiceById(serviceId);

		serviceById.ifPresentOrElse(
		service -> {
		Resource createdResource =
		resourceHelper.createResourceForService(resourceDashboardData, service);
		@@ -638,42 +638,36 @@ public class ServiceOrderAndServiceRepositories {
		serviceId));
		}

		@Transactional
		public void deleteResourceWithDashboardData(DeleteTelemetryData deleteTelemetryData) {
		String serviceId = deleteTelemetryData.getServiceId().toString();
		String resourceId = this.getDashboardResourceId(serviceId);
		if (StringUtils.isNotBlank(resourceId)) {
		resourceHelper.deleteResourceById(resourceId);
		}
		}

		@Transactional
		public String getDashboardResourceId(String serviceId) {
		AtomicReference<String> resourceID = new AtomicReference<>();
		Optional<Service> serviceOptional = serviceHelper.findServiceById(serviceId);

		serviceOptional.ifPresentOrElse(
		service -> {
		Optional<Resource> dashboardResourceOptional =
		service.getSupportingResource().stream()
		.filter(resourceRef -> resourceRef.getType().equalsIgnoreCase(DASHBOARD_RESOURCE))
		.filter(resource -> resource.getType().equalsIgnoreCase(DASHBOARD_RESOURCE))
		.findFirst();

		dashboardResourceOptional.ifPresentOrElse(
		resourceRef -> removeResourceFromService(service, resourceRef, serviceId),
		resource -> resourceID.set(resource.getId()),
		() ->
		logger.infof(
		logger.warnf(
		"No dashboard supporting resource was found for service id %s", serviceId));
		},
		() ->
		logger.infof(
		logger.warnf(
		"The service with id %s was not found and delete dashboard operation was not performed",
		serviceId));
		}

		private void removeResourceFromService(Service service, Resource resource, String serviceId) {
		// remove resource ref from service supporting resources
		service.getSupportingResource().remove(resource);

		// delete resource
		String id = resource.getId();
		resourceHelper.deleteResourceById(id);

		logger.infof(
		"Dashboard resource with id %s was found and deleted for service with id %s",
		id, serviceId);
		return resourceID.get();
		}

		public void createServiceReferences(ServiceOrderDTO serviceOrder) {