D-Net

package eu.dnetlib.dli.resolver;

import com.google.gson.JsonElement;

import com.google.gson.JsonObject;

import com.google.gson.JsonParser;

import com.mongodb.MongoClient;

import com.mongodb.client.FindIterable;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.model.Filters;

import eu.dnetlib.dli.resolver.model.DLIObjectProvenance;

import eu.dnetlib.dli.resolver.model.DLIResolvedObject;

import eu.dnetlib.enabling.tools.DnetStreamSupport;

import eu.dnetlib.pid.resolver.AbstractPIDResolver;

import eu.dnetlib.pid.resolver.model.ObjectType;

import eu.dnetlib.pid.resolver.model.SubjectType;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.bson.Document;

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

import java.util.List;

import java.util.stream.Collectors;

public class DataciteOfflineResolver extends AbstractPIDResolver {

    /**

     * The Constant log.

     */

    private static final Log log = LogFactory.getLog(DataciteOfflineResolver.class);

    private MongoClient client;

    private MongoCollection<Document> dataciteCollection;

    @Value("${dli.dataciteOfflineResolver.databaseName}")

    private String databaseName;

    @Value("${dli.dataciteOfflineResolver.collectionName}")

    private String collectionName;

    @Override

    protected boolean canResolvePid(final String pidType) {

        return (pidType != null) && ("doi".equals(pidType.toLowerCase().trim()) || "handle".equals(pidType.toLowerCase().trim()));

    }

    @Override

    public DLIResolvedObject resolve(final String pid, final String pidType) {

        try {

            final Document result = retrieveItem(pid);

            if (result!= null) {

                return parseResponse(result);

            }

        } catch (Throwable e) {

            log.error("Error on getting item with Pid: " +  pid);

        }

        return null;

    }

    private DLIResolvedObject parseResponse(Document result) {

        final String json = result.toJson();

        final JsonParser p = new JsonParser();

        JsonObject root = p.parse(json).getAsJsonObject();

        final DLIResolvedObject dli = new DLIResolvedObject();

        final  String description = getStringValue(root, "description");

        dli.setDescription(description);

        dli.setPid(getStringValue(root, "pid"));

        dli.setPidType(getStringValue(root, "pidType"));

        dli.setType(ObjectType.dataset);

        dli.setDate(getStringValue(root, "date"));

        dli.setTitles(getStringValues(root, "titles"));

        dli.setAuthors(getStringValues(root, "authors"));

        if (root.has("subjects") && root.get("subjects").isJsonArray()) {

            dli.setSubjects(

                    DnetStreamSupport.generateStreamFromIterator(root.getAsJsonArray("subjects").iterator())

                    .map(JsonElement::getAsJsonObject)

                    .map(it -> new SubjectType(it.get("scheme").getAsString(), it.get("term").getAsString()))

                    .collect(Collectors.toList())

            );

        }

        dli.setDatasourceProvenance(

                DnetStreamSupport.generateStreamFromIterator(root.getAsJsonArray("datasourceProvenance").iterator())

                .map(JsonElement::getAsJsonObject)

                .map(it -> {

                    final DLIObjectProvenance provenance =new DLIObjectProvenance();

                    provenance.setDatasourceId(it.get("datasourceId").getAsString());

                    provenance.setCompletionStatus(it.get("completionStatus").getAsString());

                    provenance.setProvisionMode(it.get("provisionMode").getAsString());

                    provenance.setDatasource(it.get("datasource").getAsString());

                    provenance.setPublisher(getStringValue(it, "publisher"));

                    return provenance;

                })

                .collect(Collectors.toList())

        );

        return dli;

    }

    private List<String> getStringValues(final JsonObject root, final String key) {

        if (root.has(key) && root.get(key).isJsonArray()) {

            return DnetStreamSupport.generateStreamFromIterator(root.getAsJsonArray(key).iterator())

                    .map(JsonElement::getAsString)

                    .collect(Collectors.toList());

        }

        return null;

    }

    private String getStringValue(final JsonObject root, final String key) {

        if (root.has(key) && !root.get(key).isJsonNull()) {

            return root.get(key).getAsString();

        }

        return null;

    }

    private Document retrieveItem(final  String pid){

        FindIterable<Document> pids = getDataciteCollection().find(Filters.eq("pid", pid));

        if (pids!= null) {

            return pids.first();

        }

        return null;

    }

    public void setMongoClient(final MongoClient client) {

        this.client = client;

    }

    private MongoCollection<Document> getDataciteCollection() {

        if (dataciteCollection == null)

        {

            dataciteCollection = client.getDatabase(databaseName).getCollection(collectionName);

        }

        return dataciteCollection;

    }

    public String getDatabaseName() {

        return databaseName;

    }

    public void setDatabaseName(String databaseName) {

        this.databaseName = databaseName;

    }

    public String getCollectionName() {

        return collectionName;

    }

    public void setCollectionName(String collectionName) {

        this.collectionName = collectionName;

    }

    @Override

    public boolean isAvailableOffline() {

        return true;

    }

}