D-Net

package eu.dnetlib.resolver.mdstore.plugin;

import com.mongodb.DBObject;

import com.mongodb.client.MongoCollection;

import eu.dnetlib.dli.DLIUtils;

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

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

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

import eu.dnetlib.dli.resolver.model.serializer.DLIResolverSerializer;

import eu.dnetlib.pid.resolver.PIDResolver;

import eu.dnetlib.pid.resolver.mdstore.plugin.AbstractRecordResolver;

import eu.dnetlib.pid.resolver.mdstore.plugin.RecordResolver;

import eu.dnetlib.pid.resolver.mdstore.plugin.ResolverMDStorePlugin;

import eu.dnetlib.pid.resolver.mdstore.plugin.ResolverSerializer;

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

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

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

import eu.dnetlib.resolver.parser.DLIParser;

import org.antlr.stringtemplate.StringTemplate;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.BlockingQueue;

import java.util.function.Function;

/**

 * Created by sandro on 9/22/16.

 */

public class DLIRecordResolver extends AbstractRecordResolver {

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

	private final DLIParser parser = new DLIParser();

    public DLIRecordResolver(long ts) {

        super(ts);

    }

    public String resolve(final String inputRecord) {

		final DLIResolvedObject inputObject = (DLIResolvedObject) parser.parse(inputRecord);

		if (inputObject==null)

			return null;

		if (StringUtils.isNoneBlank(inputObject.getResolvedDate()))

			return null;

		if (!StringUtils.isBlank(inputObject.getPid())) {

			log.debug("trying to resolve " + inputObject.getPid());

		}

		boolean shouldUpdate = false;

		if (inputObject.getCompletionStatus() == null || !inputObject.getCompletionStatus().equals(CompletionStatus.complete.toString())) {

			shouldUpdate = tryToResolveRecord(inputObject);

		}

        return resolveRelations(inputRecord, inputObject, shouldUpdate,s -> {

			try {

				return DLIUtils.getInverse(s);

			} catch (Exception e) {

				log.error("Error on getting Inverse relation from "+s, e);

				return "";

			}

		});

	}

    @Override

    protected Map<String, ObjectType> tryToResolveRelation(final PID currentPid) {

        if (currentPid.getId() != null && currentPid.getId().contains("dli_resolver")) {

			return null;

		}

		log.debug("tryToResolveRelation " + currentPid);

		for (PIDResolver resolver : pluginResolver) {

            final DLIResolvedObject currentIdentifier = (DLIResolvedObject) resolver.retrievePID(currentPid.getId(), currentPid.getType(), offline);

            if (currentIdentifier != null && !StringUtils.isBlank(currentIdentifier.getPid()) && currentIdentifier.getPid().toLowerCase().equals(currentPid.getId().toLowerCase())) {

                final HashMap<String, ObjectType> result = new HashMap<>();

				result.put("dli_resolver::" + DLIUtils.generateIdentifier(currentIdentifier.getPid(), currentIdentifier.getPidType()),

						currentIdentifier.getType());

                return result;

            }

		}

		return null;

	}

    private boolean tryToResolveRecord(final DLIResolvedObject object) {

		for (PIDResolver resolver : pluginResolver) {

            final DLIResolvedObject resolvedObject = (DLIResolvedObject) resolver.retrievePID(object.getPid(), object.getPidType(), offline);

            if (resolvedObject != null &&

					resolvedObject.getCompletionStatus() != null &&

                    resolvedObject.getCompletionStatus().equals(CompletionStatus.complete.toString())) {

                {

					object.setAuthors(resolvedObject.getAuthors());

					object.setTitles(resolvedObject.getTitles());

					object.setCompletionStatus(resolvedObject.getCompletionStatus());

					object.setDate(resolvedObject.getDate());

					object.getDatasourceProvenance().addAll(resolvedObject.getDatasourceProvenance());

					object.setDescription(resolvedObject.getDescription());

					object.setSubjects(resolvedObject.getSubjects());

					object.setType(resolvedObject.getType());

					log.debug("Record Resolved by " + resolver.getClass().getCanonicalName() + "  PID: " + object.getPid());

					return true;

				}

			}

		}

		log.debug("Record NOT Resolved  PID: " + object.getPid());

		return false;

	}

	public void setPluginResolver(final List<PIDResolver> pluginResolver) {

		this.pluginResolver = pluginResolver;

	}

	public BlockingQueue<DBObject> getInputQueue() {

		return inputQueue;

	}

	public void setInputQueue(final BlockingQueue<DBObject> inputQueue) {

		this.inputQueue = inputQueue;

	}

	public MongoCollection<DBObject> getOutputCollection() {

		return outputCollection;

	}

	public void setOutputCollection(final MongoCollection<DBObject> outputCollection) {

		this.outputCollection = outputCollection;

	}

	public void setSerializer(final ResolverSerializer serializer) {

        final DLIResolverSerializer tmp = new DLIResolverSerializer();

        tmp.setPmfTemplate(new StringTemplate(((DLIResolverSerializer) serializer).getPmfTemplate().getTemplate()));

        tmp.setDmfTemplate(new StringTemplate(((DLIResolverSerializer) serializer).getDmfTemplate().getTemplate()));

        tmp.setScholixTemplate(new StringTemplate(((DLIResolverSerializer) serializer).getScholixTemplate().getTemplate()));

        this.serializer = tmp;

	}

}