D-Net

package eu.dnetlib.dli.proto;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import com.google.common.collect.Maps;

import eu.dnetlib.data.proto.DNGFProtos.DNGFEntity;

import eu.dnetlib.data.proto.DNGFProtos.DNGFRel;

import eu.dnetlib.data.proto.DatasetProtos.Dataset;

import eu.dnetlib.data.proto.DliFieldTypeProtos;

import eu.dnetlib.data.proto.DliProtos;

import eu.dnetlib.data.proto.FieldTypeProtos.KeyValue;

import eu.dnetlib.data.proto.PublicationProtos.Publication;

import eu.dnetlib.data.proto.TypeProtos.Type;

import static eu.dnetlib.data.proto.dli.ScholixObjectProtos.*;

/**

 * Created by sandro on 2/27/17.

 */

public class DngfToScholixConverter {

    public static Scholix.Builder withSource(final DNGFEntity input) {

        return Scholix.newBuilder().setSource(asScholixResource(input));

    }

    public static Scholix.Builder withTarget(final DNGFEntity input, final DNGFRel rel) {

        final Scholix.Builder scholix = Scholix.newBuilder()

                .setTarget(asScholixResource(input))

                .setRelationship(ScholixRelationship.newBuilder().setName(rel.getRelType().getClassid()).setSchema("datacite"))

                .addAllLinkprovider(rel.getCollectedfromList()

                        .stream()

                        .map(cf ->

                            ScholixEntityId.newBuilder()

		                            .setName(cf.getValue())

		                            .addIdentifiers(

			                            ScholixIdentifier.newBuilder()

			                                    .setSchema("dnetIdentifier")

			                                    .setIdentifier(cf.getKey()))

		                            .build())

                        .collect(Collectors.toList()));

        return scholix;

    }

    private static ScholixResource asScholixResource(DNGFEntity input) {

        final ScholixResource.Builder builder = ScholixResource.newBuilder();

        //Set Identifier

        builder.addAllIdentifier(input.getExtension(DliProtos.typedIdentifier)

                .stream()

                .map(id -> ScholixIdentifier.newBuilder()

                        .setIdentifier(id.getValue())

                        .setSchema(id.getQualifier().getClassid())

		                .build())

                .collect(Collectors.toMap(

		                i -> i.getIdentifier(),

		                i -> i,

		                (v1, v2) -> v1)).values());

        builder.setDnetIdentifier(input.getId());

	    builder.addAllCreator(DngfDliUtils.parseAuthor(input)

			    .stream()

	            .map(a -> ScholixEntityId.newBuilder().setName(a).build())

			    .collect(Collectors.toList()));

	    switch (input.getType()) {

	    case publication:

			builder.setObjectType(Type.publication.name());

		    final Publication.Metadata pm = input.getPublication().getMetadata();

		    if (pm.getTitleCount() > 0) {

		    	builder.setTitle(pm.getTitleList().stream()

					    .map(t -> t.getValue())

					    .findFirst().get());

		    }

		    builder.setPublicationDate(pm.getDateofacceptance().getValue());

			builder.setPublisher(ScholixEntityId.newBuilder().setName(pm.getPublisher().getValue()));

	    	break;

	    case dataset:

		    builder.setObjectType(Type.dataset.name());

		    final Dataset.Metadata dm = input.getDataset().getMetadata();

		    if (dm.getTitleCount() > 0) {

			    builder.setTitle(dm.getTitleList().stream()

					    .map(t -> t.getValue())

					    .findFirst().get());

		    }

		    builder.setPublicationDate(dm.getDateofacceptance().getValue());

		    builder.setPublisher(ScholixEntityId.newBuilder().setName(dm.getPublisher().getValue()));

		    break;

	    case unknown:

		    builder.setObjectType(Type.unknown.name());

		    break;

	    case datasource:

	    case organization:

	    case person:

	    case project:

			throw new IllegalArgumentException("cannot transform type: " + input.getType());

	    }

	    final Map<String, ScholixCollectedFrom> datasources = Maps.newHashMap();

	    if (input.getCollectedfromCount() > 0) {

	    	input.getCollectedfromList().forEach(cf -> datasources.put(

	    			cf.getKey(),

				    getScholixCollectedFrom(cf, "collected", cf.getExtension(DliFieldTypeProtos.completionStatus))));

	    }

	    final List<KeyValue> resolvedFrom = input.getExtension(DliProtos.resolvedfrom);

	    if (resolvedFrom != null) {

	    	resolvedFrom.forEach(rf -> datasources.put(

				    rf.getKey(),

				    getScholixCollectedFrom(rf, "resolved", "complete")));

	    }

        return builder.build();

    }

	private static ScholixCollectedFrom getScholixCollectedFrom(final KeyValue rf, final String provisionMode, final String completionStatus) {

		return ScholixCollectedFrom.newBuilder()

				.setProvider(ScholixEntityId.newBuilder()

						.setName(rf.getValue())

						.addIdentifiers(ScholixIdentifier.newBuilder()

								.setIdentifier(rf.getKey())

								.setSchema("dnetIdentifier")))

				.setProvisionMode(provisionMode)

				.setCompletionStatus(completionStatus)

				.build();

	}

}