ResourceDao.java

/*
 * The coLAB project
 * Copyright (C) 2021-2023 AlbaSim, MEI, HEIG-VD, HES-SO
 *
 * Licensed under the MIT License
 */
package ch.colabproject.colab.api.persistence.jpa.document;

import ch.colabproject.colab.api.exceptions.ColabMergeException;
import ch.colabproject.colab.api.model.document.AbstractResource;
import ch.colabproject.colab.api.model.document.Resource;
import ch.colabproject.colab.api.model.document.ResourceRef;
import java.util.List;
import java.util.stream.Collectors;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Resource and resource reference persistence
 * <p>
 * Note : Most of database operations are handled by managed entities and cascade.
 *
 * @author sandra
 */
@Stateless
@LocalBean
public class ResourceDao {

    /** logger */
    private static final Logger logger = LoggerFactory.getLogger(ResourceDao.class);

    /**
     * Access to the persistence unit
     */
    @PersistenceContext(unitName = "COLAB_PU")
    private EntityManager em;

//    /**
//     * Find a resource by id
//     *
//     * @param id the id of the resource to fetch
//     *
//     * @return the resource with the given id or null if such a resource does not exist
//     */
//    private Resource findResource(Long id) {
//        logger.trace("find resource #{}", id);
//
//        return em.find(Resource.class, id);
//    }

//    /**
//     * Find a resource reference by id
//     *
//     * @param id the id of the resource reference to fetch
//     *
//     * @return the resource reference with the given id or null if such a resource reference does
//     *         not exist
//     */
//    private ResourceRef findResourceRef(Long id) {
//        logger.trace("find resource reference #{}", id);
//
//        return em.find(ResourceRef.class, id);
//    }

    /**
     * @param id the id of the resource / resource reference to fetch
     *
     * @return the resource / resource reference with the given id or null if such a resource /
     *         resource reference does not exist
     */
    public AbstractResource findResourceOrRef(Long id) {
        logger.trace("find abstract resource #{}", id);

        return em.find(AbstractResource.class, id);
    }

    /**
     * Retrieve the resources references that have the given target
     *
     * @param target the target
     *
     * @return the matching references
     */
    public List<ResourceRef> findDirectReferences(AbstractResource target) {
        logger.trace("find the direct references of the target {}", target);

        TypedQuery<ResourceRef> query = em.createNamedQuery("ResourceRef.findDirectReferences",
            ResourceRef.class);

        query.setParameter("targetId", target.getId());

        return query.getResultList();
    }

    /**
     * Retrieve all resources which transitively references the given target
     *
     * @param target the target
     *
     * @return the matching references
     */
    public List<ResourceRef> findAllReferences(AbstractResource target) {
        logger.trace("find all references to the target {}", target);

        // first, fetch direct references
        List<ResourceRef> list = findDirectReferences(target);

        // and recurse
        list.addAll(list.stream().flatMap(res -> {
            return findAllReferences(res).stream();
        }).collect(Collectors.toList()));

        return list;
    }

    /**
     * Update resource. Only fields which are editable by users will be impacted.
     *
     * @param <T>           a sub type of AbstractResource
     * @param resourceOrRef the resource as supplied by clients (ie not managed by JPA)
     *
     * @return return updated managed resource
     *
     * @throws ColabMergeException if the update failed
     */
    public <T extends AbstractResource> T updateResourceOrRef(T resourceOrRef)
        throws ColabMergeException {
        logger.trace("update resource or ref {}", resourceOrRef);

        @SuppressWarnings("unchecked")
        T managedResource = (T) this.findResourceOrRef(resourceOrRef.getId());

        managedResource.mergeToUpdate(resourceOrRef);

        return managedResource;
    }

    /**
     * Persist a brand new resource to database
     *
     * @param resource the new resource to persist
     *
     * @return the new persisted and managed resource
     */
    public Resource persistResource(Resource resource) {
        logger.trace("persist resource {}", resource);

        em.persist(resource);

        return resource;
    }

    // Note : there is no persistResourceRef because they are automatically generated
    // and are persisted by cascade

    /**
     * Delete the resource / resource reference from database. This can't be undone
     *
     * @param resourceOrRef the resource / resource reference to delete
     */
    public void deleteResourceOrRef(AbstractResource resourceOrRef) {
        logger.trace("delete abstract resource {}", resourceOrRef);

        // TODO: move to recycle bin first

        em.remove(resourceOrRef);
    }

}