D-Net

import org.junit.Ignore;

@Ignore

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

import eu.dnetlib.miscutils.datetime.DateUtils;

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

		final String parent = parents.get(gridId);

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

		final Set<String> otherNames = calculateNames(parent, org.getAcronyms());

		final Map<String, String> orgRels = otherNames.stream()

				.collect(Collectors.toMap(s -> calculateOpenaireId(ds.getPrefix(), gridId, s), s -> s));

		orgRels.put(calculateOpenaireId(ds.getPrefix(), gridId, mainName), mainName);

		final String url = org.getLinks().stream().findFirst().orElse("");

		res.add(toProto(gridId, mainName, shortName, url, country, org.getAcronyms(), orgRels, ds));

		res.addAll(otherNames.stream()

				.map(name -> toProto(gridId, name, shortName, url, country, new ArrayList<>(), orgRels, ds))

			final Map<String, String> orgRels,

		// TODO ADD ALTERNATIVE NAMES AND RELS

		final String openaireId = calculateOpenaireId(ds.getPrefix(), gridId, name);

		final KeyValue collectedFrom = KeyValue.newBuilder()

				.setKey(ds.getId())

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

		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)));

				.setEntity(entity)

						.setTrust("0.90")

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

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

	}

package eu.dnetlib.grid.process;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.stream.Collectors;

import org.springframework.boot.CommandLineRunner;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

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

import eu.dnetlib.grid.process.utils.Datasource;

import eu.dnetlib.grid.process.utils.GridCleaner;

import eu.dnetlib.grid.process.utils.GridUtils;

@SpringBootApplication

public class GridOrganizationsApplication implements CommandLineRunner {

	private static final Datasource gridDs = new Datasource("openaire____::grid", "GRID - Global Research Identifier Database", "grid________");

	public static void main(final String[] args) {

		SpringApplication.run(GridOrganizationsApplication.class, args);

	}

	@Override

	public void run(final String... args) throws Exception {

		if (args.length == 1) {

			processFile(args[0]);

		} else {

			System.err.println();

			System.err.println("Usage: java -jar <JARFILE> <GridJsonFile>");

			System.err.println();

		}

	}

	protected void processFile(final String jsonFile) throws Exception {

		final GridCleaner cleaner = new GridCleaner();

		final Map<String, String> parents = GridUtils.streamOrganizations(jsonFile)

				.filter(Objects::nonNull)

				.filter(o -> o.getStatus().equals("active"))

				.collect(Collectors.toMap(GridOrganization::getId, GridUtils::findShortName));

		GridUtils.streamOrganizations(jsonFile)

				.filter(Objects::nonNull)

				.filter(o -> o.getStatus().equals("active"))

				.map(cleaner)

				.map(org -> GridUtils.toProtos(org, parents, gridDs))

				.flatMap(List::stream)

				.map(s -> s.getEntity().getId()) // TODO OAF -> JSON

				.forEach(System.out::println);

	}

}

		<version>2.0.3.RELEASE</version>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-starter</artifactId>

		</dependency>

		<dependency>

			<version>3.9.4-SNAPSHOT</version>