2020-04-28 11:23:29 +02:00
|
|
|
|
2020-04-10 17:53:07 +02:00
|
|
|
package eu.dnetlib.dhp.oa.graph.raw;
|
2020-02-04 15:25:47 +01:00
|
|
|
|
2021-05-31 11:36:26 +02:00
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.DNET_PID_TYPES;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.IS_PRODUCED_BY;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.OUTCOME;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.PRODUCES;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.REPOSITORY_PROVENANCE_ACTIONS;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.RESULT_PROJECT;
|
|
|
|
import static eu.dnetlib.dhp.schema.common.ModelConstants.UNKNOWN;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.createOpenaireId;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.dataInfo;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.field;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.journal;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.keyValue;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.listFields;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.oaiIProvenance;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.qualifier;
|
|
|
|
import static eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils.structuredProperty;
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Date;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Optional;
|
|
|
|
import java.util.Set;
|
2020-05-23 09:57:39 +02:00
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
|
import org.dom4j.Document;
|
|
|
|
import org.dom4j.DocumentFactory;
|
|
|
|
import org.dom4j.DocumentHelper;
|
|
|
|
import org.dom4j.Node;
|
2021-05-31 11:36:26 +02:00
|
|
|
import org.slf4j.Logger;
|
|
|
|
import org.slf4j.LoggerFactory;
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-10-16 17:02:10 +02:00
|
|
|
import com.google.common.collect.Lists;
|
2021-05-10 16:43:39 +02:00
|
|
|
import com.google.common.collect.Sets;
|
2020-10-16 17:02:10 +02:00
|
|
|
|
2021-01-25 15:43:04 +01:00
|
|
|
import eu.dnetlib.dhp.common.vocabulary.VocabularyGroup;
|
2020-07-20 17:37:08 +02:00
|
|
|
import eu.dnetlib.dhp.schema.common.ModelConstants;
|
2021-05-31 11:36:26 +02:00
|
|
|
import eu.dnetlib.dhp.schema.oaf.AccessRight;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Author;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Context;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.DataInfo;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Dataset;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Field;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.GeoLocation;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Instance;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Journal;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.KeyValue;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.OAIProvenance;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Oaf;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.OafEntity;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.OtherResearchProduct;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Publication;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Qualifier;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Relation;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Result;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Software;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.StructuredProperty;
|
2020-10-16 17:02:10 +02:00
|
|
|
import eu.dnetlib.dhp.schema.oaf.utils.IdentifierFactory;
|
2021-04-27 15:44:01 +02:00
|
|
|
import eu.dnetlib.dhp.schema.oaf.utils.OafMapperUtils;
|
2020-04-20 09:43:27 +02:00
|
|
|
|
2020-03-02 16:12:14 +01:00
|
|
|
public abstract class AbstractMdRecordToOafMapper {
|
2020-02-04 15:25:47 +01:00
|
|
|
|
2020-05-27 11:34:13 +02:00
|
|
|
protected final VocabularyGroup vocs;
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-06-10 10:04:00 +02:00
|
|
|
private final boolean invisible;
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
private final boolean shouldHashId;
|
|
|
|
|
2020-05-06 13:20:02 +02:00
|
|
|
protected static final String DATACITE_SCHEMA_KERNEL_4 = "http://datacite.org/schema/kernel-4";
|
2020-08-04 12:53:48 +02:00
|
|
|
protected static final String DATACITE_SCHEMA_KERNEL_4_SLASH = "http://datacite.org/schema/kernel-4/";
|
2020-05-06 13:20:02 +02:00
|
|
|
protected static final String DATACITE_SCHEMA_KERNEL_3 = "http://datacite.org/schema/kernel-3";
|
2020-08-04 12:53:48 +02:00
|
|
|
protected static final String DATACITE_SCHEMA_KERNEL_3_SLASH = "http://datacite.org/schema/kernel-3/";
|
2020-05-26 13:11:09 +02:00
|
|
|
protected static final Qualifier ORCID_PID_TYPE = qualifier(
|
2021-06-14 09:40:50 +02:00
|
|
|
ModelConstants.ORCID_PENDING,
|
|
|
|
ModelConstants.ORCID_CLASSNAME,
|
|
|
|
DNET_PID_TYPES, DNET_PID_TYPES);
|
2020-05-26 13:11:09 +02:00
|
|
|
protected static final Qualifier MAG_PID_TYPE = qualifier(
|
|
|
|
"MAGIdentifier", "Microsoft Academic Graph Identifier", DNET_PID_TYPES, DNET_PID_TYPES);
|
2020-05-06 13:20:02 +02:00
|
|
|
|
2021-03-09 09:12:41 +01:00
|
|
|
protected static final String DEFAULT_TRUST_FOR_VALIDATED_RELS = "0.999";
|
|
|
|
|
2020-05-06 13:20:02 +02:00
|
|
|
protected static final Map<String, String> nsContext = new HashMap<>();
|
|
|
|
|
2021-05-31 11:36:26 +02:00
|
|
|
private static final Logger log = LoggerFactory.getLogger(DispatchEntitiesApplication.class);
|
|
|
|
|
2020-05-06 13:20:02 +02:00
|
|
|
static {
|
|
|
|
nsContext.put("dr", "http://www.driver-repository.eu/namespace/dr");
|
|
|
|
nsContext.put("dri", "http://www.driver-repository.eu/namespace/dri");
|
|
|
|
nsContext.put("oaf", "http://namespace.openaire.eu/oaf");
|
|
|
|
nsContext.put("oai", "http://www.openarchives.org/OAI/2.0/");
|
|
|
|
nsContext.put("prov", "http://www.openarchives.org/OAI/2.0/provenance");
|
|
|
|
nsContext.put("dc", "http://purl.org/dc/elements/1.1/");
|
|
|
|
nsContext.put("datacite", DATACITE_SCHEMA_KERNEL_3);
|
|
|
|
}
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
protected AbstractMdRecordToOafMapper(final VocabularyGroup vocs, final boolean invisible,
|
|
|
|
final boolean shouldHashId) {
|
2020-05-27 11:34:13 +02:00
|
|
|
this.vocs = vocs;
|
2020-06-10 10:04:00 +02:00
|
|
|
this.invisible = invisible;
|
2020-11-30 12:00:38 +01:00
|
|
|
this.shouldHashId = shouldHashId;
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public List<Oaf> processMdRecord(final String xml) {
|
2021-05-31 11:36:26 +02:00
|
|
|
|
|
|
|
// log.info("Processing record: " + xml);
|
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
try {
|
|
|
|
DocumentFactory.getInstance().setXPathNamespaceURIs(nsContext);
|
|
|
|
|
|
|
|
final Document doc = DocumentHelper
|
2020-08-04 12:55:27 +02:00
|
|
|
.parseText(
|
|
|
|
xml
|
|
|
|
.replaceAll(DATACITE_SCHEMA_KERNEL_4, DATACITE_SCHEMA_KERNEL_3)
|
|
|
|
.replaceAll(DATACITE_SCHEMA_KERNEL_4_SLASH, DATACITE_SCHEMA_KERNEL_3)
|
|
|
|
.replaceAll(DATACITE_SCHEMA_KERNEL_3_SLASH, DATACITE_SCHEMA_KERNEL_3));
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
final KeyValue collectedFrom = getProvenanceDatasource(
|
|
|
|
doc, "//oaf:collectedFrom/@id", "//oaf:collectedFrom/@name");
|
2020-05-06 13:20:02 +02:00
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
if (collectedFrom == null) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-05-06 13:20:02 +02:00
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
final KeyValue hostedBy = StringUtils.isBlank(doc.valueOf("//oaf:hostedBy/@id"))
|
2020-05-14 10:25:41 +02:00
|
|
|
? collectedFrom
|
|
|
|
: getProvenanceDatasource(doc, "//oaf:hostedBy/@id", "//oaf:hostedBy/@name");
|
2020-05-06 13:20:02 +02:00
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
if (hostedBy == null) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-06-10 10:04:00 +02:00
|
|
|
final DataInfo info = prepareDataInfo(doc, invisible);
|
2020-04-28 11:23:29 +02:00
|
|
|
final long lastUpdateTimestamp = new Date().getTime();
|
|
|
|
|
2020-07-20 17:33:37 +02:00
|
|
|
final List<Instance> instances = prepareInstances(doc, info, collectedFrom, hostedBy);
|
|
|
|
|
|
|
|
final String type = getResultType(doc, instances);
|
|
|
|
|
|
|
|
return createOafs(doc, type, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-04-28 11:23:29 +02:00
|
|
|
} catch (final Exception e) {
|
|
|
|
throw new RuntimeException(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-20 17:33:37 +02:00
|
|
|
protected String getResultType(final Document doc, final List<Instance> instances) {
|
2021-05-31 11:36:26 +02:00
|
|
|
final String type = doc.valueOf("//dr:CobjCategory/@type");
|
2020-07-20 17:33:37 +02:00
|
|
|
|
|
|
|
if (StringUtils.isBlank(type) & vocs.vocabularyExists(ModelConstants.DNET_RESULT_TYPOLOGIES)) {
|
2021-05-31 11:36:26 +02:00
|
|
|
final String instanceType = instances
|
2020-07-20 17:37:08 +02:00
|
|
|
.stream()
|
|
|
|
.map(i -> i.getInstancetype().getClassid())
|
|
|
|
.findFirst()
|
2020-07-20 19:01:10 +02:00
|
|
|
.map(s -> UNKNOWN.equalsIgnoreCase(s) ? "0000" : s)
|
2020-07-20 17:37:08 +02:00
|
|
|
.orElse("0000"); // Unknown
|
2020-07-20 19:01:10 +02:00
|
|
|
return Optional
|
|
|
|
.ofNullable(vocs.getSynonymAsQualifier(ModelConstants.DNET_RESULT_TYPOLOGIES, instanceType))
|
|
|
|
.map(q -> q.getClassid())
|
|
|
|
.orElse("0000");
|
|
|
|
/*
|
|
|
|
* .orElseThrow( () -> new IllegalArgumentException( String.format("'%s' not mapped in %s", instanceType,
|
|
|
|
* DNET_RESULT_TYPOLOGIES)));
|
|
|
|
*/
|
2020-07-20 17:33:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2020-05-22 12:25:01 +02:00
|
|
|
private KeyValue getProvenanceDatasource(final Document doc, final String xpathId, final String xpathName) {
|
2020-05-06 13:20:02 +02:00
|
|
|
final String dsId = doc.valueOf(xpathId);
|
|
|
|
final String dsName = doc.valueOf(xpathName);
|
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
if (StringUtils.isBlank(dsId) | StringUtils.isBlank(dsName)) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-05-06 13:20:02 +02:00
|
|
|
|
2020-05-22 12:25:01 +02:00
|
|
|
return keyValue(createOpenaireId(10, dsId, true), dsName);
|
2020-05-06 13:20:02 +02:00
|
|
|
}
|
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
protected List<Oaf> createOafs(
|
2020-05-14 10:25:41 +02:00
|
|
|
final Document doc,
|
|
|
|
final String type,
|
2020-07-20 17:33:37 +02:00
|
|
|
final List<Instance> instances,
|
2020-05-14 10:25:41 +02:00
|
|
|
final KeyValue collectedFrom,
|
|
|
|
final DataInfo info,
|
|
|
|
final long lastUpdateTimestamp) {
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-10-16 16:00:19 +02:00
|
|
|
final OafEntity entity = createEntity(doc, type, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-11-30 12:00:38 +01:00
|
|
|
final String id = IdentifierFactory.createIdentifier(entity, shouldHashId);
|
2020-10-16 16:00:19 +02:00
|
|
|
if (!id.equals(entity.getId())) {
|
|
|
|
entity.getOriginalId().add(entity.getId());
|
|
|
|
entity.setId(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
final List<Oaf> oafs = Lists.newArrayList(entity);
|
|
|
|
|
|
|
|
if (!oafs.isEmpty()) {
|
|
|
|
oafs.addAll(addProjectRels(doc, entity));
|
|
|
|
oafs.addAll(addOtherResultRels(doc, entity));
|
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-10-16 16:00:19 +02:00
|
|
|
return oafs;
|
|
|
|
}
|
|
|
|
|
2021-05-31 11:36:26 +02:00
|
|
|
private OafEntity createEntity(final Document doc,
|
|
|
|
final String type,
|
|
|
|
final List<Instance> instances,
|
|
|
|
final KeyValue collectedFrom,
|
|
|
|
final DataInfo info,
|
|
|
|
final long lastUpdateTimestamp) {
|
2020-04-28 11:23:29 +02:00
|
|
|
switch (type.toLowerCase()) {
|
2020-05-26 13:11:09 +02:00
|
|
|
case "publication":
|
|
|
|
final Publication p = new Publication();
|
2020-07-20 17:33:37 +02:00
|
|
|
populateResultFields(p, doc, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-05-26 13:11:09 +02:00
|
|
|
p.setJournal(prepareJournal(doc, info));
|
2020-10-16 16:00:19 +02:00
|
|
|
return p;
|
2020-05-26 13:11:09 +02:00
|
|
|
case "dataset":
|
|
|
|
final Dataset d = new Dataset();
|
2020-07-20 17:33:37 +02:00
|
|
|
populateResultFields(d, doc, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-05-26 13:11:09 +02:00
|
|
|
d.setStoragedate(prepareDatasetStorageDate(doc, info));
|
|
|
|
d.setDevice(prepareDatasetDevice(doc, info));
|
|
|
|
d.setSize(prepareDatasetSize(doc, info));
|
|
|
|
d.setVersion(prepareDatasetVersion(doc, info));
|
|
|
|
d.setLastmetadataupdate(prepareDatasetLastMetadataUpdate(doc, info));
|
|
|
|
d.setMetadataversionnumber(prepareDatasetMetadataVersionNumber(doc, info));
|
|
|
|
d.setGeolocation(prepareDatasetGeoLocations(doc, info));
|
2020-10-16 16:00:19 +02:00
|
|
|
return d;
|
2020-05-26 13:11:09 +02:00
|
|
|
case "software":
|
|
|
|
final Software s = new Software();
|
2020-07-20 17:33:37 +02:00
|
|
|
populateResultFields(s, doc, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-05-26 13:11:09 +02:00
|
|
|
s.setDocumentationUrl(prepareSoftwareDocumentationUrls(doc, info));
|
|
|
|
s.setLicense(prepareSoftwareLicenses(doc, info));
|
|
|
|
s.setCodeRepositoryUrl(prepareSoftwareCodeRepositoryUrl(doc, info));
|
|
|
|
s.setProgrammingLanguage(prepareSoftwareProgrammingLanguage(doc, info));
|
2020-10-16 16:00:19 +02:00
|
|
|
return s;
|
2020-05-26 13:11:09 +02:00
|
|
|
case "":
|
|
|
|
case "otherresearchproducts":
|
|
|
|
default:
|
|
|
|
final OtherResearchProduct o = new OtherResearchProduct();
|
2020-07-20 17:33:37 +02:00
|
|
|
populateResultFields(o, doc, instances, collectedFrom, info, lastUpdateTimestamp);
|
2020-05-26 13:11:09 +02:00
|
|
|
o.setContactperson(prepareOtherResearchProductContactPersons(doc, info));
|
|
|
|
o.setContactgroup(prepareOtherResearchProductContactGroups(doc, info));
|
|
|
|
o.setTool(prepareOtherResearchProductTools(doc, info));
|
2020-10-16 16:00:19 +02:00
|
|
|
return o;
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<Oaf> addProjectRels(
|
2020-05-14 10:25:41 +02:00
|
|
|
final Document doc,
|
2020-10-16 16:00:19 +02:00
|
|
|
final OafEntity entity) {
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
final List<Oaf> res = new ArrayList<>();
|
|
|
|
|
2020-10-16 16:00:19 +02:00
|
|
|
final String docId = entity.getId();
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
for (final Object o : doc.selectNodes("//oaf:projectid")) {
|
|
|
|
|
|
|
|
final String originalId = ((Node) o).getText();
|
|
|
|
|
2021-03-09 09:12:41 +01:00
|
|
|
final String validationdDate = ((Node) o).valueOf("@validationDate");
|
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
if (StringUtils.isNotBlank(originalId)) {
|
|
|
|
final String projectId = createOpenaireId(40, originalId, true);
|
|
|
|
|
2020-05-06 13:20:02 +02:00
|
|
|
res
|
2020-05-26 13:11:09 +02:00
|
|
|
.add(
|
|
|
|
getRelation(
|
2021-03-09 09:12:41 +01:00
|
|
|
docId, projectId, RESULT_PROJECT, OUTCOME, IS_PRODUCED_BY, entity, validationdDate));
|
2020-05-06 13:20:02 +02:00
|
|
|
res
|
2021-05-31 11:36:26 +02:00
|
|
|
.add(getRelation(projectId, docId, RESULT_PROJECT, OUTCOME, PRODUCES, entity, validationdDate));
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2021-03-09 09:12:41 +01:00
|
|
|
protected Relation getRelation(final String source,
|
2021-03-09 17:11:50 +01:00
|
|
|
final String target,
|
|
|
|
final String relType,
|
|
|
|
final String subRelType,
|
|
|
|
final String relClass,
|
|
|
|
final OafEntity entity) {
|
2021-03-09 09:12:41 +01:00
|
|
|
return getRelation(source, target, relType, subRelType, relClass, entity, null);
|
|
|
|
}
|
|
|
|
|
2020-05-22 12:25:01 +02:00
|
|
|
protected Relation getRelation(final String source,
|
|
|
|
final String target,
|
|
|
|
final String relType,
|
|
|
|
final String subRelType,
|
|
|
|
final String relClass,
|
2021-03-09 09:12:41 +01:00
|
|
|
final OafEntity entity,
|
2021-03-09 17:11:50 +01:00
|
|
|
final String validationDate) {
|
2020-05-06 13:20:02 +02:00
|
|
|
final Relation rel = new Relation();
|
|
|
|
rel.setRelType(relType);
|
|
|
|
rel.setSubRelType(subRelType);
|
|
|
|
rel.setRelClass(relClass);
|
|
|
|
rel.setSource(source);
|
|
|
|
rel.setTarget(target);
|
2020-10-16 16:00:19 +02:00
|
|
|
rel.setCollectedfrom(entity.getCollectedfrom());
|
|
|
|
rel.setDataInfo(entity.getDataInfo());
|
|
|
|
rel.setLastupdatetimestamp(entity.getLastupdatetimestamp());
|
2021-03-09 09:12:41 +01:00
|
|
|
rel.setValidated(StringUtils.isNotBlank(validationDate));
|
|
|
|
rel.setValidationDate(StringUtils.isNotBlank(validationDate) ? validationDate : null);
|
2020-05-06 13:20:02 +02:00
|
|
|
return rel;
|
|
|
|
}
|
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
protected abstract List<Oaf> addOtherResultRels(
|
2020-05-14 10:25:41 +02:00
|
|
|
final Document doc,
|
2020-10-16 16:00:19 +02:00
|
|
|
final OafEntity entity);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
private void populateResultFields(
|
2020-05-14 10:25:41 +02:00
|
|
|
final Result r,
|
|
|
|
final Document doc,
|
2020-07-20 17:33:37 +02:00
|
|
|
final List<Instance> instances,
|
2020-05-14 10:25:41 +02:00
|
|
|
final KeyValue collectedFrom,
|
|
|
|
final DataInfo info,
|
|
|
|
final long lastUpdateTimestamp) {
|
2020-04-28 11:23:29 +02:00
|
|
|
r.setDataInfo(info);
|
|
|
|
r.setLastupdatetimestamp(lastUpdateTimestamp);
|
|
|
|
r.setId(createOpenaireId(50, doc.valueOf("//dri:objIdentifier"), false));
|
2021-05-05 16:36:15 +02:00
|
|
|
r.setOriginalId(findOriginalId(doc));
|
2020-04-28 11:23:29 +02:00
|
|
|
r.setCollectedfrom(Arrays.asList(collectedFrom));
|
2021-03-17 12:45:38 +01:00
|
|
|
r.setPid(IdentifierFactory.getPids(prepareResultPids(doc, info), collectedFrom));
|
2021-03-16 14:19:32 +01:00
|
|
|
r.setDateofcollection(doc.valueOf("//dr:dateOfCollection/text()|//dri:dateOfCollection/text()"));
|
|
|
|
r.setDateoftransformation(doc.valueOf("//dr:dateOfTransformation/text()|//dri:dateOfTransformation/text()"));
|
2020-04-28 11:23:29 +02:00
|
|
|
r.setExtraInfo(new ArrayList<>()); // NOT PRESENT IN MDSTORES
|
|
|
|
r.setOaiprovenance(prepareOAIprovenance(doc));
|
|
|
|
r.setAuthor(prepareAuthors(doc, info));
|
|
|
|
r.setLanguage(prepareLanguages(doc));
|
|
|
|
r.setCountry(new ArrayList<>()); // NOT PRESENT IN MDSTORES
|
|
|
|
r.setSubject(prepareSubjects(doc, info));
|
|
|
|
r.setTitle(prepareTitles(doc, info));
|
|
|
|
r.setRelevantdate(prepareRelevantDates(doc, info));
|
|
|
|
r.setDescription(prepareDescriptions(doc, info));
|
|
|
|
r.setDateofacceptance(prepareField(doc, "//oaf:dateAccepted", info));
|
|
|
|
r.setPublisher(preparePublisher(doc, info));
|
|
|
|
r.setEmbargoenddate(prepareField(doc, "//oaf:embargoenddate", info));
|
|
|
|
r.setSource(prepareSources(doc, info));
|
|
|
|
r.setFulltext(new ArrayList<>()); // NOT PRESENT IN MDSTORES
|
|
|
|
r.setFormat(prepareFormats(doc, info));
|
|
|
|
r.setContributor(prepareContributors(doc, info));
|
|
|
|
r.setResourcetype(prepareResourceType(doc, info));
|
|
|
|
r.setCoverage(prepareCoverages(doc, info));
|
|
|
|
r.setContext(prepareContexts(doc, info));
|
|
|
|
r.setExternalReference(new ArrayList<>()); // NOT PRESENT IN MDSTORES
|
2020-07-20 17:33:37 +02:00
|
|
|
|
2020-05-23 09:57:39 +02:00
|
|
|
r.setInstance(instances);
|
2020-11-03 12:19:46 +01:00
|
|
|
r.setBestaccessright(OafMapperUtils.createBestAccessRights(instances));
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
|
2020-05-26 13:06:55 +02:00
|
|
|
protected abstract List<StructuredProperty> prepareResultPids(Document doc, DataInfo info);
|
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
private List<Context> prepareContexts(final Document doc, final DataInfo info) {
|
|
|
|
final List<Context> list = new ArrayList<>();
|
|
|
|
for (final Object o : doc.selectNodes("//oaf:concept")) {
|
|
|
|
final String cid = ((Node) o).valueOf("@id");
|
|
|
|
if (StringUtils.isNotBlank(cid)) {
|
|
|
|
final Context c = new Context();
|
|
|
|
c.setId(cid);
|
|
|
|
c.setDataInfo(Arrays.asList(info));
|
|
|
|
list.add(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected abstract Qualifier prepareResourceType(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Instance> prepareInstances(
|
2020-05-22 12:25:01 +02:00
|
|
|
Document doc,
|
|
|
|
DataInfo info,
|
|
|
|
KeyValue collectedfrom,
|
|
|
|
KeyValue hostedby);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareSources(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<StructuredProperty> prepareRelevantDates(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareCoverages(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareContributors(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareFormats(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> preparePublisher(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareDescriptions(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<StructuredProperty> prepareTitles(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<StructuredProperty> prepareSubjects(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Qualifier prepareLanguages(Document doc);
|
|
|
|
|
|
|
|
protected abstract List<Author> prepareAuthors(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareOtherResearchProductTools(
|
2020-05-22 12:25:01 +02:00
|
|
|
Document doc,
|
|
|
|
DataInfo info);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareOtherResearchProductContactGroups(
|
2020-05-22 12:25:01 +02:00
|
|
|
Document doc,
|
|
|
|
DataInfo info);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareOtherResearchProductContactPersons(
|
2020-05-22 12:25:01 +02:00
|
|
|
Document doc,
|
|
|
|
DataInfo info);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
protected abstract Qualifier prepareSoftwareProgrammingLanguage(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareSoftwareCodeRepositoryUrl(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<StructuredProperty> prepareSoftwareLicenses(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract List<Field<String>> prepareSoftwareDocumentationUrls(
|
2020-05-22 12:25:01 +02:00
|
|
|
Document doc,
|
|
|
|
DataInfo info);
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
protected abstract List<GeoLocation> prepareDatasetGeoLocations(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetMetadataVersionNumber(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetLastMetadataUpdate(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetVersion(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetSize(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetDevice(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
protected abstract Field<String> prepareDatasetStorageDate(Document doc, DataInfo info);
|
|
|
|
|
|
|
|
private Journal prepareJournal(final Document doc, final DataInfo info) {
|
|
|
|
final Node n = doc.selectSingleNode("//oaf:journal");
|
|
|
|
if (n != null) {
|
|
|
|
final String name = n.getText();
|
|
|
|
final String issnPrinted = n.valueOf("@issn");
|
|
|
|
final String issnOnline = n.valueOf("@eissn");
|
|
|
|
final String issnLinking = n.valueOf("@lissn");
|
|
|
|
final String ep = n.valueOf("@ep");
|
|
|
|
final String iss = n.valueOf("@iss");
|
|
|
|
final String sp = n.valueOf("@sp");
|
|
|
|
final String vol = n.valueOf("@vol");
|
|
|
|
final String edition = n.valueOf("@edition");
|
2020-05-26 13:11:09 +02:00
|
|
|
if (StringUtils.isNotBlank(name)) {
|
|
|
|
return journal(name, issnPrinted, issnOnline, issnLinking, ep, iss, sp, vol, edition, null, null, info);
|
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2021-05-05 16:36:15 +02:00
|
|
|
private List<String> findOriginalId(final Document doc) {
|
2020-07-20 09:50:29 +02:00
|
|
|
final Node n = doc.selectSingleNode("//*[local-name()='provenance']/*[local-name()='originDescription']");
|
|
|
|
if (n != null) {
|
|
|
|
final String id = n.valueOf("./*[local-name()='identifier']");
|
|
|
|
if (StringUtils.isNotBlank(id)) {
|
2021-05-05 16:36:15 +02:00
|
|
|
return Lists.newArrayList(id);
|
2020-07-20 09:50:29 +02:00
|
|
|
}
|
|
|
|
}
|
2021-05-31 11:36:26 +02:00
|
|
|
final List<String> idList = doc
|
2021-05-10 16:43:39 +02:00
|
|
|
.selectNodes(
|
|
|
|
"normalize-space(//*[local-name()='header']/*[local-name()='identifier' or local-name()='recordIdentifier']/text())");
|
2021-05-31 11:36:26 +02:00
|
|
|
final Set<String> originalIds = Sets.newHashSet(idList);
|
2020-07-20 09:50:29 +02:00
|
|
|
|
2021-05-05 16:36:15 +02:00
|
|
|
if (originalIds.isEmpty()) {
|
|
|
|
throw new IllegalStateException("missing originalID on " + doc.asXML());
|
|
|
|
}
|
|
|
|
return Lists.newArrayList(originalIds);
|
2020-07-20 09:50:29 +02:00
|
|
|
}
|
|
|
|
|
2021-01-12 15:36:38 +01:00
|
|
|
protected AccessRight prepareAccessRight(final Node node, final String xpath, final String schemeId) {
|
2021-05-31 11:36:26 +02:00
|
|
|
final Qualifier qualifier = prepareQualifier(node.valueOf(xpath).trim(), schemeId);
|
|
|
|
final AccessRight accessRight = new AccessRight();
|
2021-01-12 15:36:38 +01:00
|
|
|
accessRight.setClassid(qualifier.getClassid());
|
|
|
|
accessRight.setClassname(qualifier.getClassname());
|
|
|
|
accessRight.setSchemeid(qualifier.getSchemeid());
|
|
|
|
accessRight.setSchemename(qualifier.getSchemename());
|
|
|
|
|
|
|
|
// TODO set the OAStatus
|
|
|
|
// accessRight.setOaStatus(...);
|
|
|
|
|
|
|
|
return accessRight;
|
|
|
|
}
|
|
|
|
|
2020-05-27 11:34:13 +02:00
|
|
|
protected Qualifier prepareQualifier(final Node node, final String xpath, final String schemeId) {
|
|
|
|
return prepareQualifier(node.valueOf(xpath).trim(), schemeId);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected Qualifier prepareQualifier(final String classId, final String schemeId) {
|
|
|
|
return vocs.getTermAsQualifier(schemeId, classId);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<StructuredProperty> prepareListStructProps(
|
2020-05-22 12:25:01 +02:00
|
|
|
final Node node,
|
|
|
|
final String xpath,
|
2020-05-27 11:34:13 +02:00
|
|
|
final String xpathClassId,
|
2020-05-22 12:25:01 +02:00
|
|
|
final String schemeId,
|
2020-05-27 11:34:13 +02:00
|
|
|
final DataInfo info) {
|
|
|
|
final List<StructuredProperty> res = new ArrayList<>();
|
|
|
|
|
|
|
|
for (final Object o : node.selectNodes(xpath)) {
|
|
|
|
final Node n = (Node) o;
|
|
|
|
final String classId = n.valueOf(xpathClassId).trim();
|
|
|
|
res.add(structuredProperty(n.getText(), prepareQualifier(classId, schemeId), info));
|
|
|
|
}
|
|
|
|
return res;
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
|
2020-05-27 11:34:13 +02:00
|
|
|
protected List<StructuredProperty> prepareListStructPropsWithValidQualifier(
|
2020-05-14 10:25:41 +02:00
|
|
|
final Node node,
|
|
|
|
final String xpath,
|
|
|
|
final String xpathClassId,
|
|
|
|
final String schemeId,
|
|
|
|
final DataInfo info) {
|
2020-04-28 11:23:29 +02:00
|
|
|
final List<StructuredProperty> res = new ArrayList<>();
|
2020-05-27 11:34:13 +02:00
|
|
|
|
2020-04-28 11:23:29 +02:00
|
|
|
for (final Object o : node.selectNodes(xpath)) {
|
|
|
|
final Node n = (Node) o;
|
2020-05-27 11:34:13 +02:00
|
|
|
final String classId = n.valueOf(xpathClassId).trim();
|
|
|
|
if (vocs.termExists(schemeId, classId)) {
|
|
|
|
res.add(structuredProperty(n.getText(), vocs.getTermAsQualifier(schemeId, classId), info));
|
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<StructuredProperty> prepareListStructProps(
|
2020-05-22 12:25:01 +02:00
|
|
|
final Node node,
|
|
|
|
final String xpath,
|
|
|
|
final Qualifier qualifier,
|
|
|
|
final DataInfo info) {
|
2020-04-28 11:23:29 +02:00
|
|
|
final List<StructuredProperty> res = new ArrayList<>();
|
|
|
|
for (final Object o : node.selectNodes(xpath)) {
|
|
|
|
final Node n = (Node) o;
|
|
|
|
res.add(structuredProperty(n.getText(), qualifier, info));
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<StructuredProperty> prepareListStructProps(
|
2020-05-22 12:25:01 +02:00
|
|
|
final Node node,
|
|
|
|
final String xpath,
|
|
|
|
final DataInfo info) {
|
2020-04-28 11:23:29 +02:00
|
|
|
final List<StructuredProperty> res = new ArrayList<>();
|
|
|
|
for (final Object o : node.selectNodes(xpath)) {
|
|
|
|
final Node n = (Node) o;
|
|
|
|
res
|
2020-05-26 13:11:09 +02:00
|
|
|
.add(
|
|
|
|
structuredProperty(
|
|
|
|
n.getText(), n.valueOf("@classid"), n.valueOf("@classname"), n.valueOf("@schemeid"),
|
|
|
|
n.valueOf("@schemename"), info));
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected OAIProvenance prepareOAIprovenance(final Document doc) {
|
|
|
|
final Node n = doc.selectSingleNode("//*[local-name()='provenance']/*[local-name()='originDescription']");
|
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
if (n == null) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
final String identifier = n.valueOf("./*[local-name()='identifier']");
|
|
|
|
final String baseURL = n.valueOf("./*[local-name()='baseURL']");
|
|
|
|
final String metadataNamespace = n.valueOf("./*[local-name()='metadataNamespace']");
|
|
|
|
final boolean altered = n.valueOf("@altered").equalsIgnoreCase("true");
|
|
|
|
final String datestamp = n.valueOf("./*[local-name()='datestamp']");
|
|
|
|
final String harvestDate = n.valueOf("@harvestDate");
|
|
|
|
|
|
|
|
return oaiIProvenance(identifier, baseURL, metadataNamespace, altered, datestamp, harvestDate);
|
|
|
|
}
|
|
|
|
|
2020-06-10 10:04:00 +02:00
|
|
|
protected DataInfo prepareDataInfo(final Document doc, final boolean invisible) {
|
2020-04-28 11:23:29 +02:00
|
|
|
final Node n = doc.selectSingleNode("//oaf:datainfo");
|
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
if (n == null) {
|
2020-06-10 10:04:00 +02:00
|
|
|
return dataInfo(false, null, false, invisible, REPOSITORY_PROVENANCE_ACTIONS, "0.9");
|
2020-05-26 13:11:09 +02:00
|
|
|
}
|
2020-04-28 11:23:29 +02:00
|
|
|
|
|
|
|
final String paClassId = n.valueOf("./oaf:provenanceaction/@classid");
|
|
|
|
final String paClassName = n.valueOf("./oaf:provenanceaction/@classname");
|
|
|
|
final String paSchemeId = n.valueOf("./oaf:provenanceaction/@schemeid");
|
|
|
|
final String paSchemeName = n.valueOf("./oaf:provenanceaction/@schemename");
|
|
|
|
|
|
|
|
final boolean deletedbyinference = Boolean.parseBoolean(n.valueOf("./oaf:deletedbyinference"));
|
|
|
|
final String inferenceprovenance = n.valueOf("./oaf:inferenceprovenance");
|
|
|
|
final Boolean inferred = Boolean.parseBoolean(n.valueOf("./oaf:inferred"));
|
|
|
|
final String trust = n.valueOf("./oaf:trust");
|
|
|
|
|
2020-05-26 13:11:09 +02:00
|
|
|
return dataInfo(
|
2020-06-10 10:04:00 +02:00
|
|
|
deletedbyinference, inferenceprovenance, inferred, invisible,
|
2020-05-26 13:11:09 +02:00
|
|
|
qualifier(paClassId, paClassName, paSchemeId, paSchemeName), trust);
|
2020-04-28 11:23:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
protected Field<String> prepareField(final Node node, final String xpath, final DataInfo info) {
|
|
|
|
return field(node.valueOf(xpath), info);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<Field<String>> prepareListFields(
|
2020-05-22 12:25:01 +02:00
|
|
|
final Node node,
|
|
|
|
final String xpath,
|
|
|
|
final DataInfo info) {
|
2020-04-28 11:23:29 +02:00
|
|
|
return listFields(info, prepareListString(node, xpath));
|
|
|
|
}
|
|
|
|
|
|
|
|
protected List<String> prepareListString(final Node node, final String xpath) {
|
|
|
|
final List<String> res = new ArrayList<>();
|
|
|
|
for (final Object o : node.selectNodes(xpath)) {
|
|
|
|
final String s = ((Node) o).getText().trim();
|
|
|
|
if (StringUtils.isNotBlank(s)) {
|
|
|
|
res.add(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2020-10-30 10:56:42 +01:00
|
|
|
|
2020-02-04 15:25:47 +01:00
|
|
|
}
|