Commit 5a4aecf9 authored by Anastasios Poimenidis's avatar Anastasios Poimenidis
Browse files

fix: alter logic in PeeringHelper to fix persistence problems

parent deee6bcd

src/main/java/org/etsi/osl/hypo/api/tmf/common/api/kafka/peering/api/incoming/helper/PeeringHelper.java

+19 −20
Original line number Diff line number Diff line
@@ -56,33 +56,33 @@ public class PeeringHelper { 
        logger.infof("Received the peered organization %s service specs", organizationId);

        List<ServiceSpecificationEntity> serviceSpecificationEntityList =

                peeredOrganizationData.getServiceSpecificationEntities();

        List<ServiceSpecificationEntity> persistedServiceSpecs =

        Set<ServiceSpecificationEntity> persistedServiceSpecs =

                serviceSpecificationService.persistPeeredServiceSpecList(

                        serviceSpecificationEntityList, organizationId);



        logger.infof("Peering for organization %s: created service specs", organizationId);



        List<ServiceCandidateEntity> serviceCandidateEntityList =

        Set<ServiceCandidateEntity> serviceCandidateEntitySet =

                getServiceCandidateListFromServiceSpecs(persistedServiceSpecs);



        List<ServiceCandidateEntity> serviceCandidateEntityListPersisted =

                serviceCandidateService.persistServiceCandidates(serviceCandidateEntityList);

        Set<ServiceCandidateEntity> serviceCandidateSetPersisted =

                serviceCandidateService.persistServiceCandidates(serviceCandidateEntitySet);



        logger.infof("Peering for organization %s: created service candidates", organizationId);



        addK8sServiceCandidates(serviceCandidateEntityListPersisted);

        addK8sServiceCandidates(serviceCandidateSetPersisted);

        logger.infof(

                "Peering for organization %s: added service candidates to %s Category",

                organizationId, K8S_SERVICES);



        add5GServiceCandidates(serviceCandidateEntityListPersisted);

        add5GServiceCandidates(serviceCandidateSetPersisted);

        logger.infof(

                "Peering for organization %s: added service candidates to %s Category",

                organizationId, FIVE_G_SERVICES);



        // find or create categories and populate persisted candidates

        List<ServiceCategoryEntity> serviceCategoryEntitiesPersisted =

                getPersistedCategories(peeredOrganizationData, serviceCandidateEntityListPersisted);

                getPersistedCategories(peeredOrganizationData, serviceCandidateSetPersisted);



        logger.infof("Peering for organization %s: added service categories", organizationId);
@@ -196,12 +196,12 @@ public class PeeringHelper { 
                "Clean up catalogs, categories and candidates for organizationId: %s", organizationId);

    }



    private List<ServiceCandidateEntity> getServiceCandidateListFromServiceSpecs(

            List<ServiceSpecificationEntity> serviceSpecificationEntityList) {

    private Set<ServiceCandidateEntity> getServiceCandidateListFromServiceSpecs(

            Set<ServiceSpecificationEntity> serviceSpecificationEntityList) {



        return serviceSpecificationEntityList.stream()

                .map(PeeringHelper::getServiceCandidateEntity)

                .toList();

                .collect(Collectors.toSet());

    }



    private static ServiceCandidateEntity getServiceCandidateEntity(
@@ -213,17 +213,17 @@ public class PeeringHelper { 
        return serviceCandidateEntity;

    }



    private void addK8sServiceCandidates(List<ServiceCandidateEntity> serviceCandidateEntities) {

    private void addK8sServiceCandidates(Set<ServiceCandidateEntity> serviceCandidateEntities) {

        serviceCategoryService.addKubernetesCandidates(serviceCandidateEntities);

    }



    private void add5GServiceCandidates(List<ServiceCandidateEntity> serviceCandidateEntities) {

    private void add5GServiceCandidates(Set<ServiceCandidateEntity> serviceCandidateEntities) {

        serviceCategoryService.add5GCandidates(serviceCandidateEntities);

    }



    private List<ServiceCategoryEntity> getPersistedCategories(

            PeeredOrganizationData peeredOrganizationData,

            List<ServiceCandidateEntity> serviceCandidateEntityListPersisted) {

            Set<ServiceCandidateEntity> serviceCandidateEntitySet) {

        List<ServiceCategoryEntity> serviceCategoryIds = new ArrayList<>();



        List<ServiceCatalog> serviceCatalogs = peeredOrganizationData.getServiceCatalogs();
@@ -238,8 +238,7 @@ public class PeeringHelper { 
                            serviceCategory -> {

                                List<String> serviceSpecificationNames = serviceCategory.getSpecifications();

                                List<String> serviceSpecificationIdsInCategory =

                                        getServiceSpecIds(

                                                serviceSpecificationNames, serviceCandidateEntityListPersisted);

                                        getServiceSpecIds(serviceSpecificationNames, serviceCandidateEntitySet);

                                ServiceCategoryEntity serviceCategoryEntity =

                                        populateCategory(serviceCategory, serviceSpecificationIdsInCategory);

                                serviceCategoryIds.add(serviceCategoryEntity);
@@ -253,20 +252,20 @@ public class PeeringHelper { 
     * filters service spec ids by the names provided by the user

     *

     * @param serviceSpecificationNames

     * @param serviceCandidateEntityListPersisted

     * @param serviceCandidateEntitySet

     * @return

     */

    private List<String> getServiceSpecIds(

            List<String> serviceSpecificationNames,

            List<ServiceCandidateEntity> serviceCandidateEntityListPersisted) {

            Set<ServiceCandidateEntity> serviceCandidateEntitySet) {



        return serviceCandidateEntityListPersisted.stream()

                .filter(getServiceCandidateEntityPredicate(serviceSpecificationNames))

        return serviceCandidateEntitySet.stream()

                .filter(specificationMatchesName(serviceSpecificationNames))

                .map(BaseEntity::getTmfId)

                .toList();

    }



    private static Predicate<ServiceCandidateEntity> getServiceCandidateEntityPredicate(

    private static Predicate<ServiceCandidateEntity> specificationMatchesName(

            List<String> serviceSpecificationNames) {

        return serviceCandidateEntity -> {

            String serviceSpecName = serviceCandidateEntity.getName();

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

+11 −4
Original line number Diff line number Diff line 
package org.etsi.osl.hypo.api.tmf.common.api.services;



import jakarta.enterprise.context.ApplicationScoped;

import jakarta.inject.Inject;

import jakarta.transaction.Transactional;

import java.util.List;

import java.util.Optional;
@@ -15,7 +14,11 @@ public class RelatedPartyService { 


    private static final Logger logger = Logger.getLogger(RelatedPartyService.class);



    @Inject RelatedPartyRepository relatedPartyRepository;

    private final RelatedPartyRepository relatedPartyRepository;



    public RelatedPartyService(RelatedPartyRepository relatedPartyRepository) {

        this.relatedPartyRepository = relatedPartyRepository;

    }



    @Transactional

    public RelatedPartyEntity createRelatedPartyEntity(RelatedPartyEntity relatedPartyEntity) {
@@ -28,7 +31,7 @@ public class RelatedPartyService { 
        String relatedPartyId = relatedPartyEntity.getTmfId();

        if (relatedPartyId != null) {

            Optional<RelatedPartyEntity> optionalRelatedPartyEntity =

                    relatedPartyRepository.findById(relatedPartyId);

                    getRelatedPartyEntityById(relatedPartyId);

            if (optionalRelatedPartyEntity.isPresent()) {

                return optionalRelatedPartyEntity.get();

            }
@@ -40,7 +43,7 @@ public class RelatedPartyService { 
    @Transactional

    public RelatedPartyEntity getRelatedPartyById(String relatedPartyId) {

        Optional<RelatedPartyEntity> optionalRelatedPartyEntity =

                relatedPartyRepository.findById(relatedPartyId);

                getRelatedPartyEntityById(relatedPartyId);

        if (optionalRelatedPartyEntity.isEmpty()) {

            throw new ServiceNotFoundException(

                    String.format("The party with id : %s was not found", relatedPartyId));
@@ -50,6 +53,10 @@ public class RelatedPartyService { 


    @Transactional

    public Optional<RelatedPartyEntity> getOptionalRelatedPartyById(String relatedPartyId) {

        return getRelatedPartyEntityById(relatedPartyId);

    }



    public Optional<RelatedPartyEntity> getRelatedPartyEntityById(String relatedPartyId) {

        return relatedPartyRepository.findById(relatedPartyId);

    }

src/main/java/org/etsi/osl/hypo/api/tmf/party/api/services/IndividualService.java

+1 −1
Original line number Diff line number Diff line
@@ -88,7 +88,7 @@ public class IndividualService { 
        Individual individual = getById(id);

        individualRepository.delete(individual);

        Optional<RelatedPartyEntity> relatedPartyEntityOptional =

                relatedPartyService.getOptionalRelatedPartyById(id);

                relatedPartyService.getRelatedPartyEntityById(id);

        relatedPartyEntityOptional.ifPresent(

                relatedPartyEntity -> relatedPartyService.deleteRelatedPartyById(id));

        return individual;

src/main/java/org/etsi/osl/hypo/api/tmf/party/api/services/OrganizationService.java

+1 −1
Original line number Diff line number Diff line
@@ -137,7 +137,7 @@ public class OrganizationService { 
        }



        Optional<RelatedPartyEntity> relatedPartyEntityOptional =

                relatedPartyService.getOptionalRelatedPartyById(id);

                relatedPartyService.getRelatedPartyEntityById(id);

        relatedPartyEntityOptional.ifPresent(

                relatedPartyEntity -> relatedPartyService.deleteRelatedPartyById(id));

        return organization;

src/main/java/org/etsi/osl/hypo/api/tmf/services/catalog/api/services/ServiceCandidateService.java

+28 −18
Original line number Diff line number Diff line 
package org.etsi.osl.hypo.api.tmf.services.catalog.api.services;



import jakarta.enterprise.context.ApplicationScoped;

import jakarta.inject.Inject;

import jakarta.transaction.Transactional;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.UUID;

import org.etsi.osl.hypo.api.tmf.common.api.services.UtilService;

import org.etsi.osl.hypo.api.tmf.common.exception.DuplicateKeyException;
@@ -26,20 +26,30 @@ import org.jboss.logging.Logger; 
public class ServiceCandidateService {

    private static final Logger logger = Logger.getLogger(ServiceCandidateService.class);



    @Inject ServiceCatalogApiEntityToResponseMapper serviceCatalogueApiEntityToResponseMapper;



    @Inject ServiceCatalogApiRequestToEntityMapper serviceCatalogueApiRequestToEntityMapper;



    @Inject ServiceCatalogUpdateEntityMapper serviceCatalogUpdateEntityMapper;



    @Inject ServiceCandidateRepository serviceCandidateRepository;



    @Inject ServiceCategoryRepository serviceCategoryRepository;



    @Inject ServiceSpecificationService serviceSpecificationService;

    private final ServiceCatalogApiEntityToResponseMapper serviceCatalogueApiEntityToResponseMapper;

    private final ServiceCatalogApiRequestToEntityMapper serviceCatalogueApiRequestToEntityMapper;

    private final ServiceCatalogUpdateEntityMapper serviceCatalogUpdateEntityMapper;

    private final ServiceCandidateRepository serviceCandidateRepository;

    private final ServiceCategoryRepository serviceCategoryRepository;

    private final ServiceSpecificationService serviceSpecificationService;



    private static final String ALREADY_EXISTS = "' already exists";



    public ServiceCandidateService(

            ServiceCatalogApiEntityToResponseMapper serviceCatalogueApiEntityToResponseMapper,

            ServiceCatalogApiRequestToEntityMapper serviceCatalogueApiRequestToEntityMapper,

            ServiceCatalogUpdateEntityMapper serviceCatalogUpdateEntityMapper,

            ServiceCandidateRepository serviceCandidateRepository,

            ServiceCategoryRepository serviceCategoryRepository,

            ServiceSpecificationService serviceSpecificationService) {

        this.serviceCatalogueApiEntityToResponseMapper = serviceCatalogueApiEntityToResponseMapper;

        this.serviceCatalogueApiRequestToEntityMapper = serviceCatalogueApiRequestToEntityMapper;

        this.serviceCatalogUpdateEntityMapper = serviceCatalogUpdateEntityMapper;

        this.serviceCandidateRepository = serviceCandidateRepository;

        this.serviceCategoryRepository = serviceCategoryRepository;

        this.serviceSpecificationService = serviceSpecificationService;

    }



    public ServiceCandidate responseFromGetRequest(

            String serviceCandidateId, String fields, Map<String, String> params) {

        ServiceCandidateEntity fetchedEntity = getByIdAndCriteria(serviceCandidateId, params);
@@ -132,8 +142,8 @@ public class ServiceCandidateService { 
    }



    @Transactional

    public List<ServiceCandidateEntity> findAllCandidatesByTmfIds(List<String> serviceCandidateIds) {

        return serviceCandidateRepository.findByIdsList(serviceCandidateIds);

    public Set<ServiceCandidateEntity> findAllCandidatesByTmfIds(Set<String> serviceCandidateIds) {

        return serviceCandidateRepository.findByIdsSet(serviceCandidateIds);

    }



    @Transactional
@@ -236,14 +246,14 @@ public class ServiceCandidateService { 
        return serviceCandidate;

    }



    public List<ServiceCandidateEntity> persistServiceCandidates(

            List<ServiceCandidateEntity> serviceCandidateEntityList) {

        serviceCandidateEntityList.forEach(

    public Set<ServiceCandidateEntity> persistServiceCandidates(

            Set<ServiceCandidateEntity> serviceCandidateEntitySet) {

        serviceCandidateEntitySet.forEach(

                serviceCandidateEntity ->

                        createServiceCandidate(

                                serviceCandidateEntity,

                                UUID.fromString(serviceCandidateEntity.getServiceSpecification().getTmfId())));

        return serviceCandidateEntityList;

        return serviceCandidateEntitySet;

    }



    private ServiceCandidateEntity getCandidateByIdAndCheckIfNameAlreadyExists(