argos/dmp-backend/web/src/main/java/eu/eudat/logic/proxy/config/configloaders/DefaultConfigLoader.java

package eu.eudat.logic.proxy.config.configloaders;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import eu.eudat.models.data.pid.PidLinks;
import eu.eudat.service.reference.external.config.ExternalUrls;
import eu.eudat.service.storage.StorageFileService;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Unmarshaller;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

@Service("configLoader")
public class DefaultConfigLoader implements ConfigLoader {
    private static final Logger logger = LoggerFactory.getLogger(DefaultConfigLoader.class);
    private static final ObjectMapper mapper = new ObjectMapper();

    private XWPFDocument document;
    private XWPFDocument datasetDocument;
    private PidLinks pidLinks;
    private Map<String, String> keyToSourceMap;
    
    @Autowired
    private StorageFileService storageFileService;


    private void setDocument() {
        byte[] bytes = this.storageFileService.getH2020TemplateFile();
        try {
            this.document = new XWPFDocument(new ByteArrayInputStream(bytes));
        } catch (Exception ex) {
            logger.error("Cannot find resource", ex);
        }
    }

    private void setDatasetDocument() {
        byte[] bytes = this.storageFileService.getH2020DescriptionTemplateFile();
        try {
            this.datasetDocument = new XWPFDocument(new ByteArrayInputStream(bytes));
        } catch (Exception ex) {
            logger.error("Cannot find resource", ex);
        }
    }

    private void setPidLinks() {
        byte[] bytes = this.storageFileService.getPidLinksFile();
        try {
            ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            this.pidLinks = mapper.readValue(new ByteArrayInputStream(bytes), PidLinks.class);
        } catch (Exception ex) {
            logger.error("Cannot find resource", ex);
        }
    }

    private void setKeyToSourceMap() {
        byte[] bytes = this.storageFileService.getExternalUrlsFile();
        
        try {
            ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            this.pidLinks = mapper.readValue(new ByteArrayInputStream(bytes), PidLinks.class);
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            Document doc = documentBuilder.parse(new ByteArrayInputStream(bytes));
            if (doc == null) {
                this.keyToSourceMap = null;
                return;
            }
            String xpathExpression = "//key";
            Map<String, String> keysToSourceMap = new HashMap<>();
            List<String> keys = getXmlValuesFromXPath(doc, xpathExpression);
            keys = keys.stream().distinct().collect(Collectors.toList());
            for (String key : keys) {
                String sourceExpression = String.format("//urlConfig[key='%s']/label", key);
                List<String> sources = getXmlValuesFromXPath(doc, sourceExpression);
                if (sources.size() != 0) {
                    keysToSourceMap.put(key, sources.get(0));
                }
            }
            this.keyToSourceMap = keysToSourceMap;
            
        } catch (Exception ex) {
            logger.error("Cannot find resource", ex);
        }
    }

    

    public XWPFDocument getDocument() {
        this.setDocument();
        return document;
    }

    public XWPFDocument getDatasetDocument() {
        this.setDatasetDocument();
        return datasetDocument;
    }

    public PidLinks getPidLinks() {
        if (pidLinks == null) {
            pidLinks = new PidLinks();
            this.setPidLinks();
        }
        return pidLinks;
    }

    public Map<String, String> getKeyToSourceMap() {
        if (keyToSourceMap == null) {
            keyToSourceMap = new HashMap<>();
            this.setKeyToSourceMap();
        }
        return keyToSourceMap;
    }


    private Document getXmlDocumentFromFilePath(String filePath) {
        InputStream is = null;
        Document doc;
        try {
            is = getStreamFromPath(filePath);
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            doc = documentBuilder.parse(is);
            return doc;
        } catch (IOException | ParserConfigurationException | SAXException | NullPointerException e) {
            logger.error(e.getMessage(), e);
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
               logger.warn("Warning: Could not close a stream after reading from file: " + filePath, e);
            }
        }
        return null;
    }

    private List<String> getXmlValuesFromXPath(Document doc, String expression) {
        XPath xPath = XPathFactory.newInstance().newXPath();
        NodeList nodeList = null;
        List<String> values = new LinkedList<>();
        try {
            nodeList = (NodeList) xPath.compile(expression).evaluate(doc, XPathConstants.NODESET);
        } catch (XPathExpressionException e) {
            logger.error(e.getMessage(), e);
        }
        if (nodeList != null) {
            for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (node.hasChildNodes()) {
                    values.add(nodeList.item(i).getChildNodes().item(0).getNodeValue());
                }
            }
        }
        return values;
    }

    private InputStream getStreamFromPath(String filePath) {
        try {
            return new FileInputStream(filePath);
        } catch (FileNotFoundException e) {
            logger.info("loading from classpath");
            return getClass().getClassLoader().getResourceAsStream(filePath);
        }
    }
}