265 lines
8.3 KiB
Java
265 lines
8.3 KiB
Java
|
|
package eu.dnetlib.dhp.sx.graph.parser;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
|
import com.ximpleware.AutoPilot;
|
|
import com.ximpleware.VTDGen;
|
|
import com.ximpleware.VTDNav;
|
|
|
|
import eu.dnetlib.dhp.parser.utility.VtdUtilityParser;
|
|
import eu.dnetlib.dhp.parser.utility.VtdUtilityParser.Node;
|
|
import eu.dnetlib.dhp.schema.oaf.*;
|
|
import eu.dnetlib.dhp.schema.scholexplorer.DLIPublication;
|
|
import eu.dnetlib.dhp.schema.scholexplorer.ProvenaceInfo;
|
|
import eu.dnetlib.scholexplorer.relation.RelationMapper;
|
|
|
|
public class PublicationScholexplorerParser extends AbstractScholexplorerParser {
|
|
|
|
@Override
|
|
public List<Oaf> parseObject(final String record, final RelationMapper relationMapper) {
|
|
try {
|
|
final List<Oaf> result = new ArrayList<>();
|
|
final DLIPublication parsedObject = new DLIPublication();
|
|
final VTDGen vg = new VTDGen();
|
|
vg.setDoc(record.getBytes());
|
|
vg.parse(true);
|
|
|
|
final VTDNav vn = vg.getNav();
|
|
final AutoPilot ap = new AutoPilot(vn);
|
|
|
|
final DataInfo di = new DataInfo();
|
|
di.setTrust("0.9");
|
|
di.setDeletedbyinference(false);
|
|
di.setInvisible(false);
|
|
|
|
String dateOfCollection = VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='dateOfCollection']");
|
|
parsedObject.setDateofcollection(dateOfCollection);
|
|
|
|
final String resolvedDate = VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='resolvedDate']");
|
|
parsedObject
|
|
.setOriginalId(
|
|
Collections
|
|
.singletonList(
|
|
VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='recordIdentifier']")));
|
|
|
|
if (StringUtils.isNotBlank(resolvedDate)) {
|
|
StructuredProperty currentDate = new StructuredProperty();
|
|
currentDate.setValue(resolvedDate);
|
|
final Qualifier dateQualifier = new Qualifier();
|
|
dateQualifier.setClassname("resolvedDate");
|
|
dateQualifier.setClassid("resolvedDate");
|
|
dateQualifier.setSchemename("dnet::date");
|
|
dateQualifier.setSchemeid("dnet::date");
|
|
currentDate.setQualifier(dateQualifier);
|
|
parsedObject.setRelevantdate(Collections.singletonList(currentDate));
|
|
}
|
|
|
|
final List<Node> pid = VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap, vn, "//*[local-name()='pid']", Arrays.asList("type"));
|
|
|
|
StructuredProperty currentPid = extractIdentifier(pid, "type");
|
|
if (currentPid == null)
|
|
return null;
|
|
inferPid(currentPid);
|
|
parsedObject.setPid(Collections.singletonList(currentPid));
|
|
final String sourceId = generateId(
|
|
currentPid.getValue(), currentPid.getQualifier().getClassid(), "publication");
|
|
parsedObject.setId(sourceId);
|
|
|
|
parsedObject
|
|
.setOriginalObjIdentifier(
|
|
VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='objIdentifier']"));
|
|
|
|
String provisionMode = VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='provisionMode']");
|
|
|
|
List<Node> collectedFromNodes = VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap,
|
|
vn,
|
|
"//*[local-name()='collectedFrom']",
|
|
Arrays.asList("name", "id", "mode", "completionStatus"));
|
|
|
|
List<Node> resolvededFromNodes = VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap,
|
|
vn,
|
|
"//*[local-name()='resolvedFrom']",
|
|
Arrays.asList("name", "id", "mode", "completionStatus"));
|
|
|
|
final String publisher = VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='publisher']");
|
|
Field<String> pf = new Field<>();
|
|
pf.setValue(publisher);
|
|
|
|
parsedObject.setPublisher(pf);
|
|
final List<ProvenaceInfo> provenances = new ArrayList<>();
|
|
if (collectedFromNodes != null && collectedFromNodes.size() > 0) {
|
|
collectedFromNodes
|
|
.forEach(
|
|
it -> {
|
|
final ProvenaceInfo provenance = new ProvenaceInfo();
|
|
provenance.setId(it.getAttributes().get("id"));
|
|
provenance.setName(it.getAttributes().get("name"));
|
|
provenance.setCollectionMode(provisionMode);
|
|
provenance.setCompletionStatus(it.getAttributes().get("completionStatus"));
|
|
provenances.add(provenance);
|
|
});
|
|
}
|
|
|
|
if (resolvededFromNodes != null && resolvededFromNodes.size() > 0) {
|
|
resolvededFromNodes
|
|
.forEach(
|
|
it -> {
|
|
final ProvenaceInfo provenance = new ProvenaceInfo();
|
|
provenance.setId(it.getAttributes().get("id"));
|
|
provenance.setName(it.getAttributes().get("name"));
|
|
provenance.setCollectionMode("resolved");
|
|
provenance.setCompletionStatus(it.getAttributes().get("completionStatus"));
|
|
provenances.add(provenance);
|
|
});
|
|
}
|
|
|
|
parsedObject.setDlicollectedfrom(provenances);
|
|
parsedObject
|
|
.setCompletionStatus(
|
|
VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='completionStatus']"));
|
|
|
|
parsedObject
|
|
.setCollectedfrom(
|
|
parsedObject
|
|
.getDlicollectedfrom()
|
|
.stream()
|
|
.map(
|
|
p -> {
|
|
final KeyValue cf = new KeyValue();
|
|
cf.setKey(p.getId());
|
|
cf.setValue(p.getName());
|
|
return cf;
|
|
})
|
|
.collect(Collectors.toList()));
|
|
|
|
final List<Node> relatedIdentifiers = VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap,
|
|
vn,
|
|
"//*[local-name()='relatedIdentifier']",
|
|
Arrays
|
|
.asList(
|
|
"relatedIdentifierType", "relationType", "entityType", "inverseRelationType"));
|
|
generateRelations(
|
|
relationMapper, parsedObject, result, di, dateOfCollection, relatedIdentifiers);
|
|
|
|
final List<Node> hostedBy = VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap, vn, "//*[local-name()='hostedBy']", Arrays.asList("id", "name"));
|
|
|
|
if (hostedBy != null) {
|
|
parsedObject
|
|
.setInstance(
|
|
hostedBy
|
|
.stream()
|
|
.map(
|
|
it -> {
|
|
final Instance i = new Instance();
|
|
i.setUrl(Collections.singletonList(currentPid.getValue()));
|
|
KeyValue h = new KeyValue();
|
|
i.setHostedby(h);
|
|
h.setKey(it.getAttributes().get("id"));
|
|
h.setValue(it.getAttributes().get("name"));
|
|
return i;
|
|
})
|
|
.collect(Collectors.toList()));
|
|
}
|
|
|
|
final List<String> authorsNode = VtdUtilityParser.getTextValue(ap, vn, "//*[local-name()='creator']");
|
|
if (authorsNode != null)
|
|
parsedObject
|
|
.setAuthor(
|
|
authorsNode
|
|
.stream()
|
|
.map(
|
|
a -> {
|
|
final Author author = new Author();
|
|
author.setFullname(a);
|
|
return author;
|
|
})
|
|
.collect(Collectors.toList()));
|
|
|
|
final List<String> titles = VtdUtilityParser.getTextValue(ap, vn, "//*[local-name()='title']");
|
|
if (titles != null) {
|
|
parsedObject
|
|
.setTitle(
|
|
titles
|
|
.stream()
|
|
.map(
|
|
t -> {
|
|
final StructuredProperty st = new StructuredProperty();
|
|
st.setValue(t);
|
|
st
|
|
.setQualifier(
|
|
generateQualifier(
|
|
"main title", "main title", "dnet:dataCite_title",
|
|
"dnet:dataCite_title"));
|
|
return st;
|
|
})
|
|
.collect(Collectors.toList()));
|
|
}
|
|
|
|
Field<String> description = new Field<>();
|
|
|
|
description
|
|
.setValue(
|
|
VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='description']"));
|
|
|
|
// if (StringUtils.isNotBlank(description.getValue())
|
|
// && description.getValue().length() > 10000) {
|
|
// description.setValue(description.getValue().substring(0, 10000));
|
|
// }
|
|
|
|
parsedObject.setDescription(Collections.singletonList(description));
|
|
|
|
final String cd = VtdUtilityParser.getSingleValue(ap, vn, "//*[local-name()='date']");
|
|
|
|
StructuredProperty date = new StructuredProperty();
|
|
date.setValue(cd);
|
|
final Qualifier dq = new Qualifier();
|
|
dq.setClassname("date");
|
|
dq.setClassid("date");
|
|
dq.setSchemename("dnet::date");
|
|
dq.setSchemeid("dnet::date");
|
|
date.setQualifier(dq);
|
|
parsedObject.setRelevantdate(Collections.singletonList(date));
|
|
|
|
List<StructuredProperty> subjects = extractSubject(
|
|
VtdUtilityParser
|
|
.getTextValuesWithAttributes(
|
|
ap, vn, "//*[local-name()='subject']", Collections.singletonList("scheme")));
|
|
parsedObject.setSubject(subjects);
|
|
|
|
parsedObject.setDataInfo(di);
|
|
|
|
parsedObject.setSubject(subjects);
|
|
Qualifier q = new Qualifier();
|
|
q.setClassname("publication");
|
|
q.setClassid("publication");
|
|
q.setSchemename("publication");
|
|
q.setSchemeid("publication");
|
|
parsedObject.setResulttype(q);
|
|
result.add(parsedObject);
|
|
return result;
|
|
|
|
} catch (Throwable e) {
|
|
log.error("Input record: " + record);
|
|
log.error("Error on parsing record ", e);
|
|
return null;
|
|
}
|
|
}
|
|
}
|