argos/dmp-backend/web/src/main/java/eu/eudat/logic/managers/PrefillingManager.java

package eu.eudat.logic.managers;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.data.DescriptionTemplateEntity;
import eu.eudat.logic.mapper.prefilling.PrefillingMapper;
import eu.eudat.service.reference.external.ExternalUrlConfigProvider;
import eu.eudat.service.reference.external.RemoteFetcher;
import eu.eudat.service.reference.external.config.ExternalUrls;
import eu.eudat.service.reference.external.criteria.ExternalReferenceCriteria;
import eu.eudat.logic.proxy.config.configloaders.ConfigLoader;
import eu.eudat.service.reference.external.config.entities.PrefillingConfig;
import eu.eudat.service.reference.external.config.entities.PrefillingGet;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.data.prefilling.Prefilling;
import eu.eudat.service.storage.StorageFileService;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Unmarshaller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.io.ByteArrayInputStream;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class PrefillingManager {
    private static final Logger logger = LoggerFactory.getLogger(PrefillingManager.class);

    private final ApiContext apiContext;
    private final ObjectMapper objectMapper;
    private final DatasetManager datasetManager;
//    private final LicenseManager licenseManager;
    private final PrefillingMapper prefillingMapper;
    private final ExternalUrlConfigProvider externalUrlConfigProvider;

    @Autowired
    public PrefillingManager(ApiContext apiContext, DatasetManager datasetManager /*, LicenseManager licenseManager*/, PrefillingMapper prefillingMapper, ExternalUrlConfigProvider externalUrlConfigProvider) {
        this.apiContext = apiContext;
        this.prefillingMapper = prefillingMapper;
	    this.externalUrlConfigProvider = externalUrlConfigProvider;
	    this.objectMapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        this.datasetManager = datasetManager;
//        this.licenseManager = licenseManager;
    }

    public List<Prefilling> getPrefillings(String like) {
        ExternalReferenceCriteria externalReferenceCriteria = new ExternalReferenceCriteria();
        externalReferenceCriteria.setLike(like);
        List<Prefilling> prefillings = new ArrayList<>();
        List<Map<String, String>> map;
        Map<String, PrefillingConfig> prefillingConfigs = this.externalUrlConfigProvider.getExternalUrls().getPrefillings();
        for (PrefillingConfig prefillingConfig: prefillingConfigs.values()) {
            map = apiContext.getOperationsContext().getRemoteFetcher().getExternalGeneric(externalReferenceCriteria, prefillingConfig.getPrefillingSearch());
            prefillings.addAll(map.stream().map(submap -> objectMapper.convertValue(submap, Prefilling.class)).collect(Collectors.toList()));
            if (prefillingConfig.getPrefillingSearch().getUrlConfig().isDataInListing()) {
                List<Map<String, Object>> mapData = apiContext.getOperationsContext().getRemoteFetcher().getExternalGenericWithData(externalReferenceCriteria, prefillingConfig.getPrefillingSearch());
                for (int i = 0; i < mapData.size(); i++) {
                    prefillings.get(i).setData(mapData.get(i));
                }
                prefillings = prefillings.stream().filter(prefilling -> prefilling.getData() != null).collect(Collectors.toList());
            }
        }
        return prefillings;
    }

    public DatasetWizardModel getPrefilledDataset(String prefillId, String configId, UUID profileId) throws Exception {
        PrefillingConfig prefillingConfig = this.externalUrlConfigProvider.getExternalUrls().getPrefillings().get(configId);
        PrefillingGet prefillingGet = prefillingConfig.getPrefillingGet();
        Map<String, Object> prefillingEntity = getSingle(prefillingGet.getUrl(), prefillId);
        DescriptionTemplateEntity descriptionTemplateEntity = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().find(profileId);
        return prefillingMapper.mapPrefilledEntityToDatasetWizard(prefillingEntity, prefillingGet, prefillingConfig.getType(), descriptionTemplateEntity, datasetManager/*, licenseManager*/);
    }

    public DatasetWizardModel getPrefilledDatasetUsingData(Map<String, Object> data, String configId, UUID profileId) throws Exception {
        PrefillingConfig prefillingConfig = this.externalUrlConfigProvider.getExternalUrls().getPrefillings().get(configId);
        PrefillingGet prefillingGet = prefillingConfig.getPrefillingGet();
        DescriptionTemplateEntity descriptionTemplateEntity = apiContext.getOperationsContext().getDatabaseRepository().getDatasetProfileDao().find(profileId);
        return prefillingMapper.mapPrefilledEntityToDatasetWizard(data, prefillingGet, prefillingConfig.getType(), descriptionTemplateEntity, datasetManager/*, licenseManager*/);
    }

    private Map<String, Object> getSingle(String url, String id) {
        RestTemplate restTemplate = new RestTemplate();
        String parsedUrl = url.replace("{id}", id);
        HttpHeaders headers = new HttpHeaders();
        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        HttpEntity<String> entity = new HttpEntity("", headers);

        return restTemplate.exchange(parsedUrl, HttpMethod.GET, entity, LinkedHashMap.class).getBody();
    }
}