argos/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java

package eu.eudat.service;

import eu.eudat.audit.AuditableAction;
import eu.eudat.commons.enums.DescriptionTemplateTypeStatus;
import eu.eudat.data.DescriptionTemplateTypeEntity;
import eu.eudat.model.DescriptionTemplateType;
import eu.eudat.model.builder.DescriptionTemplateTypeBuilder;
import eu.eudat.query.DescriptionTemplateTypeQuery;
import eu.eudat.query.lookup.DescriptionTemplateTypeLookup;
import gr.cite.tools.auditing.AuditService;
import gr.cite.tools.data.builder.BuilderFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.List;
import java.util.UUID;

@Service
public class DescriptionTemplateTypeService {

    private final ApplicationContext applicationContext;

    private final BuilderFactory builderFactory;

    private final PlatformTransactionManager transactionManager;

    private final AuditService auditService;

    @PersistenceContext
    private EntityManager entityManager;

    public DescriptionTemplateTypeService(ApplicationContext applicationContext, BuilderFactory builderFactory, PlatformTransactionManager platformTransactionManager, AuditService auditService) {
        this.applicationContext = applicationContext;
        this.builderFactory = builderFactory;
        this.transactionManager = platformTransactionManager;
        this.auditService = auditService;
    }

    public List<DescriptionTemplateType> query(DescriptionTemplateTypeLookup lookup) {
        DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class);
        List<DescriptionTemplateType> results = builderFactory
                .builder(DescriptionTemplateTypeBuilder.class)
                .build(lookup.getProject(), query.fromLookup(lookup).collect());

        auditService.track(AuditableAction.DescriptionTemplateType_Query, "lookup", lookup);

        return results;
    }

    public DescriptionTemplateType get(UUID id) {
        DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class);
        DescriptionTemplateType result = builderFactory
                .builder(DescriptionTemplateTypeBuilder.class)
                .build(null, query.ids(id).first());

        auditService.track(AuditableAction.DescriptionTemplateType_Query, "id", id);

        return result;
    }

    public DescriptionTemplateTypeEntity getEntityByName(String name) {
        DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class);
        return query.names(name).first();
    }

    public DescriptionTemplateType persist(DescriptionTemplateType payload) {
        DescriptionTemplateTypeEntity created = new DescriptionTemplateTypeEntity();
        created.setName(payload.getName());
        created.setStatus(DescriptionTemplateTypeStatus.SAVED.getValue());

        DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
        definition.setName(UUID.randomUUID().toString());
        definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = null;
        try {
            status = transactionManager.getTransaction(definition);
            entityManager.persist(created);

            entityManager.flush();
            transactionManager.commit(status);
        } catch (Exception ex) {
            if (status != null)
                transactionManager.rollback(status);
            throw ex;
        }

        auditService.track(AuditableAction.DescriptionTemplateType_Persist, "persist", payload);

        DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class);
        return builderFactory
                .builder(DescriptionTemplateTypeBuilder.class)
                .build(null, query.ids(created.getId()).first());
    }

    public DescriptionTemplateType update(DescriptionTemplateType payload) {
        DescriptionTemplateTypeEntity entity = entityManager.find(DescriptionTemplateTypeEntity.class, payload.getId());
        entity.setName(payload.getName());
        entity.setStatus(payload.getStatus());
        entityManager.merge(entity);
        entityManager.flush();

        auditService.track(AuditableAction.DescriptionTemplateType_Persist, "update", payload);

        return builderFactory.builder(DescriptionTemplateTypeBuilder.class).build(null, entity);
    }

    public boolean delete(UUID id) {
        DescriptionTemplateTypeEntity entity = entityManager.find(DescriptionTemplateTypeEntity.class, id);
        if (entity == null)
            return false;
        entity.setStatus(DescriptionTemplateTypeStatus.DELETED.getValue());
        entityManager.merge(entity);
        entityManager.flush();

        auditService.track(AuditableAction.DescriptionTemplateType_Delete, "delete", id);

        return true;
    }

}