D-Net

package eu.dnetlib.grid.process.utils;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import org.apache.commons.lang3.StringUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

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

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

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

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

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

import eu.dnetlib.data.proto.KindProtos.Kind;

import eu.dnetlib.data.proto.OafProtos.Oaf;

import eu.dnetlib.data.proto.OafProtos.OafEntity;

import eu.dnetlib.data.proto.OafProtos.OafRel;

import eu.dnetlib.data.proto.OrganizationProtos.Organization;

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

import eu.dnetlib.grid.process.model.GridOrganization;

import eu.dnetlib.grid.process.model.GridResponse;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.miscutils.functional.hash.Hashing;

public class GridUtils {

	public static Stream<GridOrganization> streamOrganizations(final String jsonFile) {

		try {

			return StreamSupport.stream(GridUtils.getOrganizations(new FileInputStream(jsonFile)).spliterator(), false);

		} catch (final FileNotFoundException e) {

			e.printStackTrace();

			return Stream.empty();

		}

	}

	protected static Iterable<GridOrganization> getOrganizations(final InputStream input) {

		try {

			return new ObjectMapper().readValue(input, GridResponse.class).getInstitutes();

		} catch (final Throwable e) {

			e.printStackTrace();

			return new ArrayList<>();

		}

	}

	public static List<Oaf> toProtos(final GridOrganization org, final Map<String, String> parents, final Datasource ds) {

		final String gridId = org.getId();

		final String parent = parents.get(gridId);

		final String mainName = calculateName(parent, org.getName());

		final String shortName = findShortName(org);

		final String mainOpenaireId = calculateOpenaireId(ds.getPrefix(), gridId, mainName);

		final Map<String, String> orgNames = calculateNames(parent, org.getAcronyms())

				.stream()

				.collect(Collectors.toMap(

						s -> calculateOpenaireId(ds.getPrefix(), gridId, s),

						s -> s));

		orgNames.put(mainOpenaireId, mainName);

		final Qualifier country = org.getAddresses().stream()

				.map(addr -> Qualifier.newBuilder()

						.setClassid(addr.getCountry_code())

						.setClassname(addr.getCountry())

						.setSchemeid("dnet:countries")

						.setSchemename("dnet:countries"))

				.filter(q -> StringUtils.isNotBlank(q.getClassid()))

				.filter(q -> StringUtils.isNotBlank(q.getClassname()))

				.map(q -> q.build())

				.findFirst()

				.orElse(null);

		final KeyValue collectedFrom = KeyValue.newBuilder()

				.setKey(ds.getId())

				.setValue(ds.getName()).build();

		return orgNames.entrySet()

				.stream()

				.map(e -> toProto(e.getKey(),

						gridId,

						e.getValue(),

						shortName,

						org.getLinks().stream().findFirst().orElse(""),

						country,

						e.getKey().equals(mainOpenaireId) ? org.getAcronyms() : new ArrayList<>(),

						orgNames, collectedFrom))

				.collect(Collectors.toList());

	}

	private static Oaf toProto(final String openaireId,

			final String gridId,

			final String name,

			final String shortName,

			final String url,

			final Qualifier country,

			final List<String> acronyms,

			final Map<String, String> orgRels,

			final KeyValue collectedFrom) {

		// TODO ADD ALTERNATIVE NAMES AND RELS

		final OafEntity.Builder entity = OafEntity.newBuilder()

				.setId(openaireId)

				.addPid(StructuredProperty.newBuilder()

						.setValue(gridId)

						.setQualifier(Qualifier.newBuilder()

								.setClassid("grid")

								.setClassname("grid")

								.setSchemeid("dnet:pid_types")

								.setSchemename("dnet:pid_types")))

				.addCollectedfrom(collectedFrom)

				.setType(Type.organization)

				.setOrganization(Organization.newBuilder()

						.setMetadata(Organization.Metadata.newBuilder()

								.setLegalname(StringField.newBuilder().setValue(name))

								.setLegalshortname(StringField.newBuilder().setValue(shortName))

								.setWebsiteurl(StringField.newBuilder().setValue(url))

								.addAllAlternativeNames(acronyms.stream().map(a -> StringField.newBuilder().setValue(a).build()).collect(Collectors.toList()))

								.setCountry(country)));

		orgRels.entrySet().stream()

				.filter(e -> !e.getKey().equals(openaireId))

				.forEach(e -> entity.addCachedRel(

						OafRel.newBuilder()

								.setTarget(e.getKey())

								// TODO ??? e.getValue()

								.addCollectedfrom(collectedFrom)));

		return Oaf.newBuilder()

				.setKind(Kind.entity)

				.setLastupdatetimestamp(DateUtils.now())

				.setEntity(entity)

				.setDataInfo(DataInfo.newBuilder()

						.setTrust("0.90")

						.setInferred(false)

						.setProvenanceaction(Qualifier.newBuilder()

								.setClassid("UNKNOWN")

								.setClassname("UNKNOWN")

								.setSchemeid("dnet:provenanceActions")

								.setSchemename("dnet:provenanceActions")))

				.build();

	}

	private static String calculateOpenaireId(final String prefix, final String gridId, final String name) {

		return String.format("20|%s::%s", prefix, Hashing.md5(gridId + " " + name));

	}

	private static String calculateName(final String parent, final String simpleName) {

		return StringUtils.isBlank(parent) ? simpleName : parent + " - " + simpleName;

	}

	private static Set<String> calculateNames(final String parent, final List<String> list) {

		return list.stream()

				.map(s -> calculateName(parent, s))

				.collect(Collectors.toSet());

	}

	public static String findShortName(final GridOrganization org) {

		return org.getAcronyms()

				.stream()

				.filter(StringUtils::isNotBlank)

				.filter(s -> s.length() < 10)

				.filter(s -> s.equals(s.toUpperCase()))

				.findFirst()

				.orElse(org.getName());

	}

}