D-Net

package eu.dnetlib.goldoa.service;

import com.fasterxml.jackson.databind.JsonNode;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.dnetlib.goldoa.domain.*;

import eu.dnetlib.goldoa.service.dao.JournalDAO;

import eu.dnetlib.goldoa.service.dao.PublicationDAO;

import eu.dnetlib.goldoa.service.dao.PublisherDAO;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.transaction.annotation.Transactional;

import java.io.InputStream;

import java.net.URL;

import java.util.*;

/**

 * Created by antleb on 3/13/15.

 */

@Transactional

public class PublicationManagerImpl implements PublicationManager {

    private static Logger logger = Logger.getLogger(PublicationManagerImpl.class);

    @Autowired

    private PublicationDAO publicationDAO;

    @Autowired

    private JournalDAO journalDAO;

    @Autowired

    private PublisherDAO publisherDAO;

    @Autowired

    private PersonManager personManager;

    @Autowired

    private OrganizationManager organizationManager;

    @Override

    public Publication getPublication(String publicationId) {

        Publication publication = publicationDAO.getPublication(publicationId);

        loadPublicationRelations(publication);

        if (publication.getJournal() != null && publication.getJournal().getId() != null)

            publication.setJournal(journalDAO.getJournal(publication.getJournal().getId()));

        else

            publication.setJournal(null);

        if (publication.getPublisher() != null && publication.getPublisher().getId() != null)

            publication.setPublisher(publisherDAO.getPublisher(publication.getPublisher().getId()));

        else

            publication.setPublisher(null);

        return publication;

    }

    private void loadPublicationRelations(Publication publication) {

        publicationDAO.loadAffiliations(publication);

    }

    @Override

    public Publication savePublication(Publication publication) {

        if (publication.getId() == null) {

            publication.setSource("portal");

            publication.setId("portal::" + DigestUtils.md5Hex(publication.getTitle()));

        }

        publicationDAO.savePublication(publication);

        deletePublicationRelations(publication);

        try {

            insertPublicationRelations(publication);

        } catch (PersonManagerException e) {

            e.printStackTrace();

        } catch (OrganizationManagerException e) {

            e.printStackTrace();

        }

        if (publication.getJournal() != null && publication.getJournal().getId() != null)

            publication.setJournal(journalDAO.getJournal(publication.getJournal().getId()));

        else

            publication.setJournal(null);

        if (publication.getPublisher() != null && publication.getPublisher().getId() != null)

            publication.setPublisher(publisherDAO.getPublisher(publication.getPublisher().getId()));

        else

            publication.setPublisher(null);

        return publication;

    }

    private void insertPublicationRelations(Publication publication) throws PersonManagerException, OrganizationManagerException {

        publicationDAO.insertIdentifiers(publication);

        if (publication.getAuthors() != null)

            for (Affiliation aff:publication.getAuthors()) {

                if (aff.getOrganization() != null && aff.getOrganization().getId() == null)

                   aff.getOrganization().setId(organizationManager.saveOrganization(aff.getOrganization()));

                if (aff.getPerson() != null) {

                    String personId = personManager.generateId(aff.getPerson());

                    try {

                        boolean affiliationExists = false;

                        Person temp = personManager.getById(personId);

                        for (Affiliation a:temp.getAffiliations()) {

                            if (a.getOrganization() != null && aff.getOrganization() != null && a.getOrganization().getId().equals(aff.getOrganization().getId()))

                               affiliationExists = true;

                        }

                        if (!affiliationExists) {

                            temp.getAffiliations().add(aff);

                            personManager.savePerson(temp);

                        }

                        aff.setPerson(temp);

                    } catch (PersonManagerException e) {

                        if (e.getErrorCause() == PersonManagerException.ErrorCause.NOT_EXISTS)

                            personManager.savePerson(aff.getPerson());

                    }

                }

            }

        publicationDAO.saveAffiliations(publication);

    }

    private void deletePublicationRelations(Publication publication) {

        publicationDAO.deleteIdentifiers(publication);

        publicationDAO.deleteAffiliations(publication);

    }

    @Override

    public Publication resolveDOI(String doi) throws ManagerException {

        Publication publication = new Publication();

        InputStream is = null;

        try {

            is = new URL("http://api.crossref.org/works/" + doi).openStream();

            ObjectMapper mapper = new ObjectMapper();

            JsonNode root = mapper.readTree(is);

            if (root.get("status").textValue().equals("ok")) {

                publication.setTitle(root.path("message").path("title").path(0).textValue());

                publication.setDoi(doi);

                publication.setSubjects(root.path("message").path("subject").textValue());

                publication.setSource("crossref");

                publication.setId("crossref::"  + DigestUtils.md5Hex(doi));

                if ("journal-article".equals(root.path("message").path("type").textValue()))

                    publication.setType(Publication.Type.ARTICLE);

                else

                    publication.setType(Publication.Type.MONOGRAPH);

                publication.setPublicationDate(this.parsePublicationDate(root.path("message").path("issued")));

                publication.setJournal(this.parseJournal(root.path("message").path("container-title"), root.path("message").path("ISSN")));

                publication.getJournal().setPublisher(this.parsePublisher(root.path("message").path("publisher")));

                publication.setAuthors(new ArrayList<Affiliation>());

                for (JsonNode author : root.path("message").path("author")) {

                    publication.getAuthors().add(this.parseAffiliation(author));

                }

                publication.setIdentifiers(new ArrayList<PublicationIdentifier>());

                publication.getIdentifiers().add(new PublicationIdentifier("doi", doi));

            } else {

                throw new ManagerException(ManagerException.ErrorCause.NOT_EXISTS);

            }

        } catch (ManagerException e) {

            throw e;

        } catch (Exception e) {

            logger.error("Error resolving doi", e);

            throw new ManagerException(ManagerException.ErrorCause.UNKNOWN);

        } finally {

            try {

                if (is != null)

                    is.close();

            } catch (Exception e) {}

        }

        return publication;

    }

    private Affiliation parseAffiliation(JsonNode author) {

        Person person = new Person();

        person.setName(author.path("given").textValue());

        person.setLastname(author.path("family").textValue());

        person.setAffiliations(new ArrayList<Affiliation>());

        Affiliation affiliation = new Affiliation();

        affiliation.setPerson(person);

        person.getAffiliations().add(affiliation);

        return affiliation;

    }

    private Publisher parsePublisher(JsonNode publisherName) {

        Publisher publisher = new Publisher();

        publisher.setName(publisherName.textValue());

        publisher.setId("crossref::" + DigestUtils.md5Hex(publisher.getName()));

        publisher.setSource("crossref");

        return publisher;

    }

    private Journal parseJournal(JsonNode name, JsonNode issn) {

        Journal journal;

        List<Vocabulary> journals = journalDAO.search(name.path(0).textValue());

        if (journals.size() > 0) {

            journal = journalDAO.getJournal(journals.get(0).getId());

        } else {

            journal = new Journal();

            journal.setTitle(name.path(0).textValue());

            journal.setAlternativeTitle(name.path(1).textValue());

            StringBuilder sb = new StringBuilder();

            Iterator<JsonNode> ssn = issn.elements();

            while (ssn.hasNext()) {

                sb.append(ssn.next().textValue()).append(",");

            }

            if (sb.length() > 0)

                sb.deleteCharAt(sb.length() - 1);

            journal.setIssn(sb.toString());

            journal.setSource("crossref");

            journal.setId("crossref::" + DigestUtils.md5Hex(journal.getTitle()));

        }

        return journal;

    }

    private Date parsePublicationDate(JsonNode node) {

        Calendar c = Calendar.getInstance();

        c.clear();

        c.setTimeZone(TimeZone.getTimeZone("UTC"));

        c.set(Calendar.YEAR, node.path("date-parts").path(0).path(0).intValue());

        c.set(Calendar.MONTH, node.path("date-parts").path(0).path(1).intValue() - 1);

        c.set(Calendar.DAY_OF_MONTH, 1 + node.path("date-parts").path(0).path(2).intValue());

        c.set(Calendar.HOUR_OF_DAY, 0);

        return c.getTime();

    }

    public PublicationDAO getPublicationDAO() {

        return publicationDAO;

    }

    public void setPublicationDAO(PublicationDAO publicationDAO) {

        this.publicationDAO = publicationDAO;

    }

    public JournalDAO getJournalDAO() {

        return journalDAO;

    }

    public void setJournalDAO(JournalDAO journalDAO) {

        this.journalDAO = journalDAO;

    }

    public PublisherDAO getPublisherDAO() {

        return publisherDAO;

    }

    public void setPublisherDAO(PublisherDAO publisherDAO) {

        this.publisherDAO = publisherDAO;

    }

}