argos/dmp-backend/web/src/main/java/eu/eudat/logic/services/externalreferences/ExternalReferenceService.java

package eu.eudat.logic.services.externalreferences;

import eu.eudat.authorization.Permission;
import eu.eudat.commons.enums.ExternalReferencesType;
import eu.eudat.commons.scope.user.UserScope;
import eu.eudat.convention.ConventionService;
import eu.eudat.data.dao.criteria.DataRepositoryCriteria;
import eu.eudat.data.dao.criteria.ExternalDatasetCriteria;
import eu.eudat.data.dao.criteria.RegistryCriteria;
import eu.eudat.data.dao.criteria.ServiceCriteria;
import eu.eudat.data.old.DataRepository;
import eu.eudat.data.old.ExternalDataset;
import eu.eudat.data.old.Registry;
import eu.eudat.data.old.Service;
import eu.eudat.logic.builders.model.criteria.ExternalDatasetCriteriaBuilder;
import eu.eudat.logic.proxy.config.ExternalUrlCriteria;
import eu.eudat.logic.proxy.config.exceptions.HugeResultSet;
import eu.eudat.logic.proxy.config.exceptions.NoURLFound;
import eu.eudat.logic.proxy.fetching.RemoteFetcher;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.model.deleter.ExternalReferenceDeleter;
import eu.eudat.models.data.FetcherExternalReference;
import eu.eudat.queryable.QueryableList;
import gr.cite.commons.web.authz.service.AuthorizationService;
import gr.cite.tools.data.builder.BuilderFactory;
import gr.cite.tools.data.deleter.DeleterFactory;
import gr.cite.tools.data.query.QueryFactory;
import gr.cite.tools.exception.MyForbiddenException;
import gr.cite.tools.logging.LoggerService;
import jakarta.persistence.EntityManager;
import org.slf4j.LoggerFactory;
import org.springframework.context.MessageSource;

import javax.management.InvalidApplicationException;
import java.util.*;
import java.util.stream.Collectors;

@org.springframework.stereotype.Service
public class ExternalReferenceService {

    private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(ExternalReferenceService.class));
    private final ApiContext apiContext;
    private final UserScope userScope;
    private final RemoteFetcher remoteFetcher;
    private final EntityManager entityManager;
    private final AuthorizationService authorizationService;
    private final DeleterFactory deleterFactory;
    private final BuilderFactory builderFactory;
    private final ConventionService conventionService;
    private final MessageSource messageSource;
    private final QueryFactory queryFactory;

    public ExternalReferenceService(ApiContext apiContext,
                                        UserScope userScope,
                                        RemoteFetcher remoteFetcher,
                                        EntityManager entityManager,
                                        AuthorizationService authorizationService,
                                        DeleterFactory deleterFactory,
                                        BuilderFactory builderFactory,
                                        ConventionService conventionService,
                                        MessageSource messageSource,
                                        QueryFactory queryFactory) {
        this.apiContext = apiContext;
        this.userScope = userScope;
        this.remoteFetcher = remoteFetcher;
        this.entityManager = entityManager;
        this.authorizationService = authorizationService;
        this.deleterFactory = deleterFactory;
        this.builderFactory = builderFactory;
        this.conventionService = conventionService;
        this.messageSource = messageSource;
        this.queryFactory = queryFactory;
    }

    public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException {
        logger.debug("deleting : {}", id);

        this.authorizationService.authorizeForce(Permission.DeleteExternalReference);

        this.deleterFactory.deleter(ExternalReferenceDeleter.class).deleteAndSaveByIds(List.of(id));
    }

    // external references:
    //    taxonomies,
    //    licenses,
    //    publications,
    //    journals,
    //    pubRepositories,
    //    dataRepositories
    //    registries,
    //    services
    public List<FetcherExternalReference> searchExternalReference(ExternalReferencesType externalType, String query, String type) throws HugeResultSet, NoURLFound, InvalidApplicationException {
        ExternalUrlCriteria externalUrlCriteria = new ExternalUrlCriteria(query);

        List<Map<String, String>> remoteRepos = null;
        if (externalType.equals(ExternalReferencesType.Datasets)){
            remoteRepos = remoteFetcher.getDatasets(externalUrlCriteria, type);
        }else {
            remoteRepos = this.apiContext.getOperationsContext().getRemoteFetcher().get(externalType, externalUrlCriteria, type);
        }

        List<FetcherExternalReference> list = this.fetchFromDb(externalType, query, type, remoteRepos);
        
        list.addAll(remoteRepos.stream().map(FetcherExternalReference::fromRemoteModel).toList());
        list = list.stream().filter(x -> x.getName().toLowerCase().contains(query.toLowerCase())).collect(Collectors.toList());
        list.sort(Comparator.comparing(FetcherExternalReference::getName));
        return list;
    }

    private List<FetcherExternalReference> fetchFromDb(ExternalReferencesType externalType, String query, String type, List<Map<String, String>> remoteRepos) throws InvalidApplicationException {
        List<FetcherExternalReference> list = new LinkedList<>();
        switch (externalType) {
            case DataRepositories:
            case PubRepositories:
            case Journals: {
                DataRepositoryCriteria criteria = new DataRepositoryCriteria();
                if (!query.isEmpty()) criteria.setLike(query);
                criteria.setCreationUserId(this.userScope.getUserId());
                if (type.equals("")) {
                    List<DataRepository> dataRepositoryList = (this.apiContext.getOperationsContext().getDatabaseRepository().getDataRepositoryDao().getWithCriteria(criteria)).toList();
                    list = dataRepositoryList.stream().map(item -> new FetcherExternalReference().fromDataRepository(item)).collect(Collectors.toList());
                }
            }
            case Registries: {
                RegistryCriteria criteria = new RegistryCriteria();
                if (!query.isEmpty()) criteria.setLike(query);
                criteria.setCreationUserId(this.userScope.getUserId());
                if (type.equals("")) {
                    List<Registry> registryList = (this.apiContext.getOperationsContext().getDatabaseRepository().getRegistryDao().getWithCriteria(criteria)).toList();
                    list = registryList.stream().map(item -> new FetcherExternalReference().fromRegistry(item)).collect(Collectors.toList());
                }
            }
            case Services:
            {
                ServiceCriteria criteria = new ServiceCriteria();

                if (!query.isEmpty()) criteria.setLike(query);
                criteria.setCreationUserId(this.userScope.getUserId());
    
                if (type.equals("")) {
                    List<Service> serviceList = (this.apiContext.getOperationsContext().getDatabaseRepository().getServiceDao().getWithCriteria(criteria)).toList();
                   list = serviceList.stream().map(item -> new FetcherExternalReference().fromService(item)).collect(Collectors.toList());
                }
            }
            case Datasets:{

                ExternalDatasetCriteria criteria = apiContext.getOperationsContext().getBuilderFactory().getBuilder(ExternalDatasetCriteriaBuilder.class).like(query).build();

                criteria.setCreationUserId(this.userScope.getUserId());
                QueryableList<ExternalDataset> items = apiContext.getOperationsContext().getDatabaseRepository().getExternalDatasetDao().getWithCriteria(criteria);

                list = items.select(item -> new FetcherExternalReference().fromDataset(item));
            }
            case Taxonomies:
            case Publications:
            case Licenses:
                break;
        }
        
        return list;
    }

}