697 lines
24 KiB
Java
697 lines
24 KiB
Java
|
|
package eu.dnetlib.dhp.oa.provision.model;
|
|
|
|
import static org.apache.commons.lang3.StringUtils.substringBefore;
|
|
|
|
import java.io.StringReader;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.dom4j.Document;
|
|
import org.dom4j.DocumentException;
|
|
import org.dom4j.io.SAXReader;
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
import com.google.common.base.Splitter;
|
|
import com.google.common.collect.Lists;
|
|
import com.google.common.collect.Maps;
|
|
import com.google.common.collect.Sets;
|
|
|
|
import eu.dnetlib.dhp.common.vocabulary.VocabularyGroup;
|
|
import eu.dnetlib.dhp.common.vocabulary.VocabularyTerm;
|
|
import eu.dnetlib.dhp.oa.provision.RelationList;
|
|
import eu.dnetlib.dhp.oa.provision.SortableRelation;
|
|
import eu.dnetlib.dhp.oa.provision.utils.ContextDef;
|
|
import eu.dnetlib.dhp.oa.provision.utils.ContextMapper;
|
|
import eu.dnetlib.dhp.schema.common.ModelSupport;
|
|
import eu.dnetlib.dhp.schema.oaf.*;
|
|
import eu.dnetlib.dhp.schema.solr.*;
|
|
import eu.dnetlib.dhp.schema.solr.AccessRight;
|
|
import eu.dnetlib.dhp.schema.solr.Author;
|
|
import eu.dnetlib.dhp.schema.solr.Context;
|
|
import eu.dnetlib.dhp.schema.solr.Country;
|
|
import eu.dnetlib.dhp.schema.solr.Datasource;
|
|
import eu.dnetlib.dhp.schema.solr.EoscIfGuidelines;
|
|
import eu.dnetlib.dhp.schema.solr.Instance;
|
|
import eu.dnetlib.dhp.schema.solr.Journal;
|
|
import eu.dnetlib.dhp.schema.solr.OpenAccessColor;
|
|
import eu.dnetlib.dhp.schema.solr.OpenAccessRoute;
|
|
import eu.dnetlib.dhp.schema.solr.Organization;
|
|
import eu.dnetlib.dhp.schema.solr.Project;
|
|
import eu.dnetlib.dhp.schema.solr.Result;
|
|
import eu.dnetlib.dhp.schema.solr.Subject;
|
|
|
|
public class ProvisionModelSupport {
|
|
|
|
private ProvisionModelSupport() {
|
|
}
|
|
|
|
public static Class[] getModelClasses() {
|
|
List<Class<?>> modelClasses = Lists.newArrayList(ModelSupport.getOafModelClasses());
|
|
modelClasses
|
|
.addAll(
|
|
Lists
|
|
.newArrayList(
|
|
RelatedEntityWrapper.class,
|
|
JoinedEntity.class,
|
|
RelatedEntity.class,
|
|
SortableRelationKey.class,
|
|
SortableRelation.class,
|
|
RelationList.class));
|
|
return modelClasses.toArray(new Class[] {});
|
|
}
|
|
|
|
public static SolrRecord transform(JoinedEntity je, ContextMapper contextMapper, VocabularyGroup vocs) {
|
|
SolrRecord r = new SolrRecord();
|
|
final OafEntity e = je.getEntity();
|
|
final RecordType type = RecordType.valueOf(e.getClass().getSimpleName().toLowerCase());
|
|
final Boolean deletedbyinference = Optional
|
|
.ofNullable(e.getDataInfo())
|
|
.map(DataInfo::getDeletedbyinference)
|
|
.orElse(null);
|
|
r
|
|
.setHeader(
|
|
SolrRecordHeader
|
|
.newInstance(
|
|
e.getId(), e.getOriginalId(), type, deletedbyinference));
|
|
r.setCollectedfrom(asProvenance(e.getCollectedfrom()));
|
|
r.setContext(asContext(e.getContext(), contextMapper));
|
|
r.setPid(asPid(e.getPid()));
|
|
|
|
if (e instanceof eu.dnetlib.dhp.schema.oaf.Result) {
|
|
r.setResult(mapResult((eu.dnetlib.dhp.schema.oaf.Result) e));
|
|
} else if (e instanceof eu.dnetlib.dhp.schema.oaf.Datasource) {
|
|
r.setDatasource(mapDatasource((eu.dnetlib.dhp.schema.oaf.Datasource) e));
|
|
} else if (e instanceof eu.dnetlib.dhp.schema.oaf.Organization) {
|
|
r.setOrganization(mapOrganization((eu.dnetlib.dhp.schema.oaf.Organization) e));
|
|
} else if (e instanceof eu.dnetlib.dhp.schema.oaf.Project) {
|
|
r.setProject(mapProject((eu.dnetlib.dhp.schema.oaf.Project) e, vocs));
|
|
}
|
|
r
|
|
.setLinks(
|
|
Optional
|
|
.ofNullable(je.getLinks())
|
|
.map(
|
|
links -> links
|
|
.stream()
|
|
.map(rew -> mapRelatedRecord(rew, vocs))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null));
|
|
|
|
return r;
|
|
}
|
|
|
|
private static RelatedRecord mapRelatedRecord(RelatedEntityWrapper rew, VocabularyGroup vocs) {
|
|
RelatedRecord rr = new RelatedRecord();
|
|
|
|
final RelatedEntity re = rew.getTarget();
|
|
final RecordType relatedRecordType = RecordType.valueOf(re.getType());
|
|
final Relation relation = rew.getRelation();
|
|
rr
|
|
.setHeader(
|
|
RelatedRecordHeader
|
|
.newInstance(
|
|
relation.getRelType(),
|
|
relation.getRelClass(),
|
|
relation.getTarget(), relatedRecordType));
|
|
|
|
rr.setAcronym(re.getAcronym());
|
|
rr.setCode(re.getCode());
|
|
rr.setContracttype(mapCodeLabel(re.getContracttype()));
|
|
rr.setCollectedfrom(asProvenance(re.getCollectedfrom()));
|
|
rr.setCodeRepositoryUrl(re.getCodeRepositoryUrl());
|
|
rr.setCountry(asCountry(re.getCountry()));
|
|
rr.setDatasourcetype(mapCodeLabel(re.getDatasourcetype()));
|
|
rr.setDatasourcetypeui(mapCodeLabel(re.getDatasourcetypeui()));
|
|
rr.setDateofacceptance(re.getDateofacceptance());
|
|
rr.setFunding(mapFunding(re.getFundingtree(), vocs));
|
|
rr.setInstances(mapInstances(re.getInstances()));
|
|
rr.setLegalname(re.getLegalname());
|
|
rr.setLegalshortname(re.getLegalshortname());
|
|
rr.setOfficialname(re.getOfficialname());
|
|
rr.setOpenairecompatibility(mapCodeLabel(re.getOpenairecompatibility()));
|
|
rr.setPid(asPid(re.getPid()));
|
|
rr.setProjectTitle(rr.getProjectTitle());
|
|
rr.setPublisher(re.getPublisher());
|
|
rr.setResulttype(mapQualifier(re.getResulttype()));
|
|
rr.setTitle(Optional.ofNullable(re.getTitle()).map(StructuredProperty::getValue).orElse(null));
|
|
|
|
return rr;
|
|
}
|
|
|
|
private static Project mapProject(eu.dnetlib.dhp.schema.oaf.Project p, VocabularyGroup vocs) {
|
|
Project ps = new Project();
|
|
ps.setAcronym(mapField(p.getAcronym()));
|
|
ps.setCode(mapField(p.getCode()));
|
|
ps.setContracttype(mapCodeLabel(p.getContracttype()));
|
|
ps.setCurrency(mapField(p.getCurrency()));
|
|
ps.setDuration(mapField(p.getDuration()));
|
|
ps.setCallidentifier(mapField(p.getCallidentifier()));
|
|
ps.setEcarticle29_3(mapField(p.getEcarticle29_3()));
|
|
ps.setEnddate(mapField(p.getEnddate()));
|
|
ps.setFundedamount(p.getFundedamount());
|
|
ps.setKeywords(mapField(p.getKeywords()));
|
|
ps.setStartdate(mapField(p.getStartdate()));
|
|
ps.setSubjects(asSubjectSP(p.getSubjects()));
|
|
ps.setSummary(mapField(p.getSummary()));
|
|
ps.setTitle(mapField(p.getTitle()));
|
|
ps.setTotalcost(p.getTotalcost());
|
|
ps.setWebsiteurl(mapField(p.getWebsiteurl()));
|
|
ps.setFunding(mapFundingField(p.getFundingtree(), vocs));
|
|
return ps;
|
|
}
|
|
|
|
private static Funding mapFunding(List<String> fundingtree, VocabularyGroup vocs) {
|
|
SAXReader reader = new SAXReader();
|
|
return Optional
|
|
.ofNullable(fundingtree)
|
|
.flatMap(
|
|
ftree -> ftree
|
|
.stream()
|
|
.map(ft -> {
|
|
try {
|
|
Document doc = reader.read(new StringReader(ft));
|
|
String countryCode = doc.valueOf("/fundingtree/funder/jurisdiction/text()");
|
|
Country country = vocs
|
|
.find("dnet:countries")
|
|
.map(voc -> voc.getTerm(countryCode))
|
|
.map(VocabularyTerm::getName)
|
|
.map(label -> Country.newInstance(countryCode, label))
|
|
.orElse(null);
|
|
|
|
String level0_id = doc.valueOf("//funding_level_0/id/text()");
|
|
String level1_id = doc.valueOf("//funding_level_1/id/text()");
|
|
String level2_id = doc.valueOf("//funding_level_2/id/text()");
|
|
|
|
return Funding
|
|
.newInstance(
|
|
Funder
|
|
.newInstance(
|
|
doc.valueOf("/fundingtree/funder/id/text()"),
|
|
doc.valueOf("/fundingtree/funder/shortname/text()"),
|
|
doc.valueOf("/fundingtree/funder/name/text()"),
|
|
country, new ArrayList<>()),
|
|
Optional
|
|
.ofNullable(level0_id)
|
|
.map(
|
|
id -> FundingLevel
|
|
.newInstance(
|
|
id,
|
|
doc.valueOf("//funding_level_0/description/text()"),
|
|
doc.valueOf("//funding_level_0/name/text()")))
|
|
.orElse(null),
|
|
Optional
|
|
.ofNullable(level1_id)
|
|
.map(
|
|
id -> FundingLevel
|
|
.newInstance(
|
|
id,
|
|
doc.valueOf("//funding_level_1/description/text()"),
|
|
doc.valueOf("//funding_level_1/name/text()")))
|
|
.orElse(null),
|
|
Optional
|
|
.ofNullable(level2_id)
|
|
.map(
|
|
id -> FundingLevel
|
|
.newInstance(
|
|
id,
|
|
doc.valueOf("//funding_level_2/description/text()"),
|
|
doc.valueOf("//funding_level_2/name/text()")))
|
|
.orElse(null));
|
|
|
|
} catch (DocumentException e) {
|
|
throw new IllegalArgumentException(e);
|
|
}
|
|
})
|
|
.findFirst())
|
|
.orElse(null);
|
|
}
|
|
|
|
private static Funding mapFundingField(List<Field<String>> fundingtree, VocabularyGroup vocs) {
|
|
return mapFunding(
|
|
Optional
|
|
.ofNullable(fundingtree)
|
|
.map(fts -> fts.stream().map(Field::getValue).collect(Collectors.toList()))
|
|
.orElse(null),
|
|
vocs);
|
|
}
|
|
|
|
private static Organization mapOrganization(eu.dnetlib.dhp.schema.oaf.Organization o) {
|
|
Organization org = new Organization();
|
|
org.setCountry(mapCodeLabel(o.getCountry()));
|
|
org.setLegalname(mapField(o.getLegalname()));
|
|
org.setLegalshortname(mapField(o.getLegalshortname()));
|
|
org.setAlternativeNames(mapFieldList(o.getAlternativeNames()));
|
|
org.setWebsiteurl(mapField(o.getWebsiteurl()));
|
|
org.setLogourl(mapField(o.getLogourl()));
|
|
|
|
org.setEcenterprise(mapField(o.getEcenterprise()));
|
|
org.setEchighereducation(mapField(o.getEchighereducation()));
|
|
org.setEclegalbody(mapField(o.getEclegalbody()));
|
|
org.setEcinternationalorganization(mapField(o.getEcinternationalorganization()));
|
|
org.setEcinternationalorganizationeurinterests(mapField(o.getEcinternationalorganizationeurinterests()));
|
|
org.setEclegalperson(mapField(o.getEclegalperson()));
|
|
org.setEcnonprofit(mapField(o.getEcnonprofit()));
|
|
org.setEcnutscode(mapField(o.getEcnutscode()));
|
|
org.setEcresearchorganization(mapField(o.getEcresearchorganization()));
|
|
org.setEcsmevalidated(mapField(o.getEcsmevalidated()));
|
|
|
|
return org;
|
|
}
|
|
|
|
private static Datasource mapDatasource(eu.dnetlib.dhp.schema.oaf.Datasource d) {
|
|
Datasource ds = new Datasource();
|
|
ds.setEnglishname(mapField(d.getEnglishname()));
|
|
ds.setOfficialname(mapField(d.getOfficialname()));
|
|
ds.setDescription(mapField(d.getDescription()));
|
|
ds.setJournal(mapJournal(d.getJournal()));
|
|
ds.setLogourl(mapField(d.getLogourl()));
|
|
ds.setAccessinfopackage(mapFieldList(d.getAccessinfopackage()));
|
|
ds.setCertificates(mapField(d.getCertificates()));
|
|
ds.setCitationguidelineurl(mapField(d.getCitationguidelineurl()));
|
|
ds.setConsenttermsofuse(d.getConsenttermsofuse());
|
|
ds.setConsenttermsofusedate(d.getConsenttermsofusedate());
|
|
ds.setContactemail(mapField(d.getContactemail()));
|
|
ds.setContentpolicies(mapCodeLabel(d.getContentpolicies()));
|
|
ds.setDatabaseaccessrestriction(mapField(d.getDatabaseaccessrestriction()));
|
|
ds.setDatabaseaccesstype(mapField(d.getDatabaseaccesstype()));
|
|
ds.setDataprovider(mapField(d.getDataprovider()));
|
|
ds.setDatasourcetype(mapCodeLabel(d.getDatasourcetype()));
|
|
ds.setDatasourcetypeui(mapCodeLabel(d.getDatasourcetypeui()));
|
|
ds.setDatauploadrestriction(mapField(d.getDatauploadrestriction()));
|
|
ds.setDatauploadtype(mapField(d.getDatauploadtype()));
|
|
ds.setDateofvalidation(mapField(d.getDateofvalidation()));
|
|
ds.setEoscdatasourcetype(mapCodeLabel(d.getEoscdatasourcetype()));
|
|
ds.setEosctype(mapCodeLabel(d.getEosctype()));
|
|
ds.setFulltextdownload(d.getFulltextdownload());
|
|
ds.setJurisdiction(mapCodeLabel(d.getJurisdiction()));
|
|
ds.setLanguages(d.getLanguages());
|
|
ds.setLatitude(mapField(d.getLatitude()));
|
|
ds.setLongitude(mapField(d.getLongitude()));
|
|
ds.setLastconsenttermsofusedate(d.getLastconsenttermsofusedate());
|
|
ds.setMissionstatementurl(mapField(d.getMissionstatementurl()));
|
|
ds.setNamespaceprefix(mapField(d.getNamespaceprefix()));
|
|
ds.setOdcontenttypes(mapFieldList(d.getOdcontenttypes()));
|
|
ds.setOdlanguages(mapFieldList(d.getOdlanguages()));
|
|
ds.setOdnumberofitems(mapField(d.getOdnumberofitems()));
|
|
ds.setOdnumberofitemsdate(mapField(d.getOdnumberofitemsdate()));
|
|
ds.setOdpolicies(mapField(d.getOdpolicies()));
|
|
ds.setOpenairecompatibility(mapCodeLabel(d.getOpenairecompatibility()));
|
|
ds.setPidsystems(mapField(d.getPidsystems()));
|
|
ds.setPolicies(mapCodeLabelKV(d.getPolicies()));
|
|
ds.setPreservationpolicyurl(d.getPreservationpolicyurl());
|
|
ds.setProvidedproducttypes(ds.getProvidedproducttypes());
|
|
ds.setReleaseenddate(mapField(d.getReleasestartdate()));
|
|
ds.setReleasestartdate(mapField(d.getReleasestartdate()));
|
|
ds.setResearchentitytypes(ds.getResearchentitytypes());
|
|
ds.setResearchproductaccesspolicies(d.getResearchproductaccesspolicies());
|
|
ds.setResearchproductmetadataaccesspolicies(d.getResearchproductmetadataaccesspolicies());
|
|
ds.setServiceprovider(mapField(d.getServiceprovider()));
|
|
ds.setSubjects(asSubjectSP(d.getSubjects()));
|
|
ds.setSubmissionpolicyurl(d.getSubmissionpolicyurl());
|
|
ds.setThematic(d.getThematic());
|
|
ds.setVersioncontrol(d.getVersioncontrol());
|
|
ds.setVersioning(mapField(d.getVersioning()));
|
|
|
|
return ds;
|
|
}
|
|
|
|
private static Result mapResult(eu.dnetlib.dhp.schema.oaf.Result r) {
|
|
Result rs = new Result();
|
|
|
|
rs.setResulttype(mapQualifier(r.getResulttype()));
|
|
rs.setAuthor(asAuthor(r.getAuthor()));
|
|
rs.setMaintitle(getMaintitle(r.getTitle()));
|
|
rs.setOtherTitles(getOtherTitles(r.getTitle()));
|
|
rs.setDescription(mapFieldList(r.getDescription()));
|
|
rs.setSubject(asSubject(r.getSubject()));
|
|
rs.setPublicationdate(mapField(r.getDateofacceptance()));
|
|
rs.setPublisher(mapField(r.getPublisher()));
|
|
rs.setEmbargoenddate(mapField(r.getEmbargoenddate()));
|
|
rs.setSource(mapFieldList(r.getSource()));
|
|
rs.setFormat(mapFieldList(r.getFormat()));
|
|
rs.setContributor(mapFieldList(r.getContributor()));
|
|
rs.setCoverage(mapFieldList(r.getCoverage()));
|
|
rs
|
|
.setBestaccessright(
|
|
BestAccessRight
|
|
.newInstance(r.getBestaccessright().getClassid(), r.getBestaccessright().getClassname()));
|
|
rs.setFulltext(mapFieldList(r.getFulltext()));
|
|
rs.setCountry(asCountry(r.getCountry()));
|
|
rs.setEoscifguidelines(asEOSCIF(r.getEoscifguidelines()));
|
|
|
|
rs.setGreen(r.getIsGreen());
|
|
rs
|
|
.setOpenAccessColor(
|
|
Optional
|
|
.ofNullable(r.getOpenAccessColor())
|
|
.map(color -> OpenAccessColor.valueOf(color.toString()))
|
|
.orElse(null));
|
|
rs.setInDiamondJournal(r.getIsInDiamondJournal());
|
|
rs.setPubliclyFunded(r.getPubliclyFunded());
|
|
rs.setTransformativeAgreement(r.getTransformativeAgreement());
|
|
|
|
rs.setInstance(mapInstances(r.getInstance()));
|
|
|
|
if (r instanceof Publication) {
|
|
Publication pub = (Publication) r;
|
|
rs.setJournal(mapJournal(pub.getJournal()));
|
|
} else if (r instanceof Dataset) {
|
|
Dataset d = (Dataset) r;
|
|
rs.setSize(mapField(d.getSize()));
|
|
rs.setVersion(mapField(d.getVersion()));
|
|
} else if (r instanceof Software) {
|
|
Software sw = (Software) r;
|
|
rs.setCodeRepositoryUrl(mapField(sw.getCodeRepositoryUrl()));
|
|
rs.setProgrammingLanguage(mapQualifier(sw.getProgrammingLanguage()));
|
|
rs.setDocumentationUrl(mapFieldList(sw.getDocumentationUrl()));
|
|
} else if (r instanceof OtherResearchProduct) {
|
|
OtherResearchProduct orp = (OtherResearchProduct) r;
|
|
rs.setContactperson(mapFieldList(orp.getContactperson()));
|
|
rs.setContactgroup(mapFieldList(orp.getContactgroup()));
|
|
rs.setTool(mapFieldList(orp.getTool()));
|
|
}
|
|
return rs;
|
|
}
|
|
|
|
@Nullable
|
|
private static List<String> getOtherTitles(List<StructuredProperty> titleList) {
|
|
return Optional
|
|
.ofNullable(titleList)
|
|
.map(
|
|
titles -> titles
|
|
.stream()
|
|
.filter(
|
|
t -> !"main title"
|
|
.equals(
|
|
Optional
|
|
.ofNullable(t.getQualifier())
|
|
.map(Qualifier::getClassid)
|
|
.orElse(null)))
|
|
.map(StructuredProperty::getValue)
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static String getMaintitle(List<StructuredProperty> titleList) {
|
|
return Optional
|
|
.ofNullable(titleList)
|
|
.flatMap(
|
|
titles -> titles
|
|
.stream()
|
|
.filter(
|
|
t -> "main title"
|
|
.equals(
|
|
Optional
|
|
.ofNullable(t.getQualifier())
|
|
.map(Qualifier::getClassid)
|
|
.orElse(null)))
|
|
.map(StructuredProperty::getValue)
|
|
.findFirst())
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Instance> mapInstances(List<eu.dnetlib.dhp.schema.oaf.Instance> instanceList) {
|
|
return Optional
|
|
.ofNullable(instanceList)
|
|
.map(
|
|
instances -> instances
|
|
.stream()
|
|
.map(instance -> {
|
|
Instance i = new Instance();
|
|
i.setCollectedfrom(asProvenance(instance.getCollectedfrom()));
|
|
i.setHostedby(asProvenance(instance.getHostedby()));
|
|
i.setFulltext(i.getFulltext());
|
|
i.setPid(asPid(instance.getPid()));
|
|
i.setAlternateIdentifier(asPid(instance.getAlternateIdentifier()));
|
|
i.setAccessright(mapAccessRight(instance.getAccessright()));
|
|
i.setInstancetype(mapQualifier(instance.getInstancetype()));
|
|
i.setLicense(mapField(instance.getLicense()));
|
|
i.setUrl(instance.getUrl());
|
|
i.setRefereed(mapQualifier(instance.getRefereed()));
|
|
i.setDateofacceptance(mapField(instance.getDateofacceptance()));
|
|
i.setDistributionlocation(instance.getDistributionlocation());
|
|
i.setProcessingcharges(getProcessingcharges(instance));
|
|
return i;
|
|
})
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static APC getProcessingcharges(eu.dnetlib.dhp.schema.oaf.Instance instance) {
|
|
return Optional
|
|
.of(
|
|
APC
|
|
.newInstance(
|
|
mapField(instance.getProcessingchargecurrency()),
|
|
mapField(instance.getProcessingchargeamount())))
|
|
.filter(apc -> Objects.nonNull(apc.getAmount()) && Objects.nonNull(apc.getCurrency()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static AccessRight mapAccessRight(eu.dnetlib.dhp.schema.oaf.AccessRight accessright) {
|
|
return AccessRight
|
|
.newInstance(
|
|
mapQualifier(accessright),
|
|
Optional
|
|
.ofNullable(accessright.getOpenAccessRoute())
|
|
.map(route -> OpenAccessRoute.valueOf(route.toString()))
|
|
.orElse(null));
|
|
}
|
|
|
|
private static <T> T mapField(eu.dnetlib.dhp.schema.oaf.Field<T> f) {
|
|
return Optional.ofNullable(f).map(Field::getValue).orElse(null);
|
|
}
|
|
|
|
private static <T> List<T> mapFieldList(List<eu.dnetlib.dhp.schema.oaf.Field<T>> fl) {
|
|
return Optional
|
|
.ofNullable(fl)
|
|
.map(v -> v.stream().map(Field::getValue).collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static String mapQualifier(eu.dnetlib.dhp.schema.oaf.Qualifier q) {
|
|
return Optional.ofNullable(q).map(Qualifier::getClassid).orElse(null);
|
|
}
|
|
|
|
private static Journal mapJournal(eu.dnetlib.dhp.schema.oaf.Journal joaf) {
|
|
return Optional
|
|
.ofNullable(joaf)
|
|
.map(jo -> {
|
|
Journal j = new Journal();
|
|
j.setConferencedate(jo.getConferencedate());
|
|
j.setConferenceplace(jo.getConferenceplace());
|
|
j.setEdition(jo.getEdition());
|
|
j.setSp(jo.getSp());
|
|
j.setEp(jo.getEp());
|
|
j.setVol(jo.getVol());
|
|
j.setIss(jo.getEdition());
|
|
j.setName(jo.getName());
|
|
j.setIssnPrinted(jo.getIssnPrinted());
|
|
j.setIssnOnline(jo.getIssnOnline());
|
|
j.setIssnLinking(jo.getIssnLinking());
|
|
return j;
|
|
})
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Provenance> asProvenance(List<KeyValue> keyValueList) {
|
|
return Optional
|
|
.ofNullable(keyValueList)
|
|
.map(
|
|
kvs -> kvs
|
|
.stream()
|
|
.map(ProvisionModelSupport::asProvenance)
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static Provenance asProvenance(KeyValue keyValue) {
|
|
return Optional.ofNullable(keyValue).map(cf -> Provenance.newInstance(cf.getKey(), cf.getValue())).orElse(null);
|
|
}
|
|
|
|
private static List<Context> asContext(List<eu.dnetlib.dhp.schema.oaf.Context> ctxList,
|
|
ContextMapper contextMapper) {
|
|
|
|
final Set<String> contexts = Optional
|
|
.ofNullable(ctxList)
|
|
.map(
|
|
ctx -> ctx
|
|
.stream()
|
|
.map(eu.dnetlib.dhp.schema.oaf.Context::getId)
|
|
.collect(Collectors.toCollection(HashSet::new)))
|
|
.orElse(new HashSet<>());
|
|
|
|
/* FIXME: Workaround for CLARIN mining issue: #3670#note-29 */
|
|
if (contexts.contains("dh-ch::subcommunity::2")) {
|
|
contexts.add("clarin");
|
|
}
|
|
|
|
return Optional
|
|
.ofNullable(contexts)
|
|
.map(
|
|
ctx -> ctx
|
|
.stream()
|
|
.map(contextPath -> {
|
|
Context context = new Context();
|
|
String id = "";
|
|
Map<String, Category> categoryMap = Maps.newHashMap();
|
|
for (final String token : Splitter.on("::").split(contextPath)) {
|
|
id += token;
|
|
|
|
final ContextDef def = contextMapper.get(id);
|
|
|
|
if (def == null) {
|
|
continue;
|
|
}
|
|
if (def.getName().equals("context")) {
|
|
context.setId(def.getId());
|
|
context.setLabel(def.getLabel());
|
|
context.setType(def.getType());
|
|
}
|
|
if (def.getName().equals("category")) {
|
|
Category category = Category.newInstance(def.getId(), def.getLabel());
|
|
if (Objects.isNull(context.getCategory())) {
|
|
context.setCategory(Lists.newArrayList());
|
|
}
|
|
context.getCategory().add(category);
|
|
categoryMap.put(def.getId(), category);
|
|
}
|
|
if (def.getName().equals("concept")) {
|
|
String parentId = StringUtils.substringBeforeLast(def.getId(), "::");
|
|
if (categoryMap.containsKey(parentId)) {
|
|
categoryMap
|
|
.get(parentId)
|
|
.getConcept()
|
|
.add(Concept.newInstance(def.getId(), def.getLabel()));
|
|
}
|
|
}
|
|
id += "::";
|
|
}
|
|
return context;
|
|
})
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Pid> asPid(List<StructuredProperty> pidList) {
|
|
return Optional
|
|
.ofNullable(pidList)
|
|
.map(
|
|
pids -> pids
|
|
.stream()
|
|
.map(p -> Pid.newInstance(p.getQualifier().getClassid(), p.getValue()))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Author> asAuthor(List<eu.dnetlib.dhp.schema.oaf.Author> authorList) {
|
|
return Optional
|
|
.ofNullable(authorList)
|
|
.map(
|
|
authors -> authors
|
|
.stream()
|
|
.map(
|
|
a -> Author
|
|
.newInstance(a.getFullname(), a.getName(), a.getSurname(), a.getRank(), asPid(a.getPid())))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Subject> asSubject(List<eu.dnetlib.dhp.schema.oaf.Subject> subjectList) {
|
|
return Optional
|
|
.ofNullable(subjectList)
|
|
.map(
|
|
subjects -> subjects
|
|
.stream()
|
|
.filter(s -> Objects.nonNull(s.getQualifier()))
|
|
.filter(s -> Objects.nonNull(s.getQualifier().getClassid()))
|
|
.map(s -> Subject.newInstance(s.getValue(), s.getQualifier().getClassid()))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Subject> asSubjectSP(List<eu.dnetlib.dhp.schema.oaf.StructuredProperty> subjectList) {
|
|
return Optional
|
|
.ofNullable(subjectList)
|
|
.map(
|
|
subjects -> subjects
|
|
.stream()
|
|
.filter(s -> Objects.nonNull(s.getQualifier()))
|
|
.filter(s -> Objects.nonNull(s.getQualifier().getClassid()))
|
|
.map(s -> Subject.newInstance(s.getValue(), s.getQualifier().getClassid()))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static Country asCountry(eu.dnetlib.dhp.schema.oaf.Qualifier country) {
|
|
return Optional
|
|
.ofNullable(country)
|
|
.filter(c -> Objects.nonNull(c.getClassid()) && Objects.nonNull(c.getClassname()))
|
|
.map(c -> Country.newInstance(c.getClassid(), c.getClassname()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<Country> asCountry(List<eu.dnetlib.dhp.schema.oaf.Country> countryList) {
|
|
return Optional
|
|
.ofNullable(countryList)
|
|
.map(
|
|
countries -> countries
|
|
.stream()
|
|
.map(c -> Country.newInstance(c.getClassid(), c.getClassname()))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<EoscIfGuidelines> asEOSCIF(List<eu.dnetlib.dhp.schema.oaf.EoscIfGuidelines> eoscIfGuidelines) {
|
|
return Optional
|
|
.ofNullable(eoscIfGuidelines)
|
|
.map(
|
|
eoscif -> eoscif
|
|
.stream()
|
|
.map(
|
|
e -> EoscIfGuidelines
|
|
.newInstance(e.getCode(), e.getLabel(), e.getUrl(), e.getSemanticRelation()))
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<CodeLabel> mapCodeLabelKV(List<KeyValue> kvList) {
|
|
return Optional
|
|
.ofNullable(kvList)
|
|
.map(
|
|
kvs -> kvs
|
|
.stream()
|
|
.map(ProvisionModelSupport::mapCodeLabel)
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static List<CodeLabel> mapCodeLabel(List<Qualifier> qualifiers) {
|
|
return Optional
|
|
.ofNullable(qualifiers)
|
|
.map(
|
|
list -> list
|
|
.stream()
|
|
.map(ProvisionModelSupport::mapCodeLabel)
|
|
.collect(Collectors.toList()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static CodeLabel mapCodeLabel(Qualifier qualifier) {
|
|
return Optional
|
|
.ofNullable(qualifier)
|
|
.map(q -> CodeLabel.newInstance(q.getClassid(), q.getClassname()))
|
|
.orElse(null);
|
|
}
|
|
|
|
private static CodeLabel mapCodeLabel(KeyValue kv) {
|
|
return Optional
|
|
.ofNullable(kv)
|
|
.map(q -> CodeLabel.newInstance(kv.getKey(), kv.getValue()))
|
|
.orElse(null);
|
|
}
|
|
|
|
}
|