private void add(
CodingSchemeReference codingSchemeReference,
ValueSetDefinitionEntry cts2Entry,
org.LexGrid.valueSets.ValueSetDefinition definition) {
CompleteCodeSystemReference ccr = new CompleteCodeSystemReference();
String codeSystemName = codingSchemeReference.getCodingScheme();
SupportedCodingScheme supportedCodingScheme = this.findCodingScheme(definition, codeSystemName);
ccr.setCodeSystem(
this.getTransformUtils()
.toCodeSystemReference(
supportedCodingScheme.getLocalId(), supportedCodingScheme.getUri()));
cts2Entry.setCompleteCodeSystem(ccr);
}
private void add(
PropertyReference propertyReference,
ValueSetDefinitionEntry cts2Entry,
org.LexGrid.valueSets.ValueSetDefinition definition) {
PropertyQueryReference pqr = new PropertyQueryReference();
String codingScheme = propertyReference.getCodingScheme();
SupportedCodingScheme supportedCodingScheme = this.findCodingScheme(definition, codingScheme);
pqr.setCodeSystem(
this.getTransformUtils()
.toCodeSystemReference(
supportedCodingScheme.getLocalId(), supportedCodingScheme.getUri()));
String propertyName = propertyReference.getPropertyName();
String matchAlgorithm = propertyReference.getPropertyMatchValue().getMatchAlgorithm();
String matchValue = propertyReference.getPropertyMatchValue().getContent();
SupportedProperty supportedProperty = this.findProperty(definition.getMappings(), propertyName);
String propName;
String propUri;
if (StringUtils.isBlank(propertyName)) {
// TODO: What is the correct behavior here?
propName = "UNSPECIFIED";
propUri = "UNSPECIFIED";
} else {
propName = supportedProperty.getLocalId();
propUri = supportedProperty.getUri();
}
FilterComponent filter = new FilterComponent();
filter.setMatchAlgorithm(new MatchAlgorithmReference());
filter.getMatchAlgorithm().setContent(matchAlgorithm);
filter.setPropertyReference(new URIAndEntityName());
filter.getPropertyReference().setName(propName);
filter.getPropertyReference().setUri(propUri);
filter.setMatchValue(matchValue);
pqr.setFilter(filter);
cts2Entry.setPropertyQuery(pqr);
}
private void add(
ValueSetDefinitionReference valueSetDefinitionReference, ValueSetDefinitionEntry cts2Entry) {
String uri = valueSetDefinitionReference.getValueSetDefinitionURI();
String name;
try {
name =
this.lexEVSValueSetDefinitionServices
.getValueSetDefinition(new URI(uri), null)
.getValueSetDefinitionName();
} catch (Exception e) {
// couldn't find it in LexEVS -- use the URI.
name = uri;
}
ValueSetReference ref = this.getTransformUtils().toValueSetReference(name);
CompleteValueSetReference vsr = new CompleteValueSetReference();
vsr.setValueSet(ref);
cts2Entry.setCompleteValueSet(vsr);
}
public ValueSetDefinitionListEntry transformFullDescription(
org.LexGrid.valueSets.ValueSetDefinition lexEvsVSD) {
if (lexEvsVSD == null) {
return null;
}
ValueSetDefinition cts2VSD = new ValueSetDefinition();
cts2VSD.setAbout(lexEvsVSD.getValueSetDefinitionURI());
cts2VSD.setDocumentURI(lexEvsVSD.getValueSetDefinitionURI());
cts2VSD.setFormalName(lexEvsVSD.getValueSetDefinitionURI());
SourceAndNotation sourceAndNotation = new SourceAndNotation();
sourceAndNotation.setSourceAndNotationDescription("LexEVS");
cts2VSD.setSourceAndNotation(sourceAndNotation);
if (lexEvsVSD.getEntityDescription() != null) {
String content = lexEvsVSD.getEntityDescription().getContent();
EntryDescription description = new EntryDescription();
description.setValue(ModelUtils.toTsAnyType(content));
cts2VSD.setResourceSynopsis(description);
}
cts2VSD.setDefinedValueSet(
this.getTransformUtils().toValueSetReference(lexEvsVSD.getValueSetDefinitionName()));
for (DefinitionEntry entry : lexEvsVSD.getDefinitionEntry()) {
ValueSetDefinitionEntry cts2Entry = new ValueSetDefinitionEntry();
if (entry.getCodingSchemeReference() != null) {
this.add(entry.getCodingSchemeReference(), cts2Entry, lexEvsVSD);
}
if (entry.getEntityReference() != null) {
this.add(entry.getEntityReference(), cts2Entry, lexEvsVSD);
}
if (entry.getPropertyReference() != null) {
this.add(entry.getPropertyReference(), cts2Entry, lexEvsVSD);
}
if (entry.getValueSetDefinitionReference() != null) {
this.add(entry.getValueSetDefinitionReference(), cts2Entry);
}
Long order = entry.getRuleOrder();
if (order == null || order == 0) {
order = 1l;
}
cts2Entry.setEntryOrder(order);
cts2Entry.setOperator(this.toSetOperator(entry.getOperator()));
cts2VSD.addEntry(cts2Entry);
}
ValueSetDefinitionListEntry listEntry = new ValueSetDefinitionListEntry();
listEntry.addEntry(cts2VSD);
ValueSetNamePair pair =
this.valueSetNameTranslator.getDefinitionNameAndVersion(
lexEvsVSD.getValueSetDefinitionURI());
listEntry.setResourceName(pair.getDefinitionLocalId());
listEntry.setHref(
this.getUrlConstructor()
.createValueSetDefinitionUrl(pair.getValueSetName(), pair.getDefinitionLocalId()));
return listEntry;
}
private void add(
EntityReference entityReference,
ValueSetDefinitionEntry cts2Entry,
org.LexGrid.valueSets.ValueSetDefinition lexEvsVSD) {
URIAndEntityName uriAndName = new URIAndEntityName();
uriAndName.setName(entityReference.getEntityCode());
String namespace = entityReference.getEntityCodeNamespace();
if (StringUtils.isBlank(namespace)) {
namespace = lexEvsVSD.getDefaultCodingScheme();
}
uriAndName.setNamespace(namespace);
SupportedNamespace supportedNamespace = this.findNamespace(lexEvsVSD.getMappings(), namespace);
if (supportedNamespace == null) {
log.warn(
"EntityRefernece: "
+ entityReference.getEntityCodeNamespace()
+ ":"
+ entityReference.getEntityCode()
+ " does not have a valid namespace.");
try {
CodingScheme cs = this.lexBigService.resolveCodingScheme(namespace, null);
SupportedNamespace sns = new SupportedNamespace();
sns.setContent(cs.getCodingSchemeName());
sns.setEquivalentCodingScheme(cs.getCodingSchemeName());
sns.setLocalId(cs.getCodingSchemeName());
sns.setUri(cs.getCodingSchemeURI());
supportedNamespace = sns;
} catch (LBException e) {
log.info(e);
// we have to punt here
SupportedNamespace sns = new SupportedNamespace();
sns.setContent("unknown");
sns.setEquivalentCodingScheme("unknown");
sns.setLocalId("unknown");
sns.setUri("unknown");
}
}
uriAndName.setUri(
UriUtils.combine(supportedNamespace.getUri(), entityReference.getEntityCode()));
if (entityReference.getReferenceAssociation() != null) {
AssociatedEntitiesReference ref = new AssociatedEntitiesReference();
ref.setReferencedEntity(uriAndName);
ref.setDirection(
entityReference.getTargetToSource()
? AssociationDirection.TARGET_TO_SOURCE
: AssociationDirection.SOURCE_TO_TARGET);
String cs = supportedNamespace.getEquivalentCodingScheme();
SupportedCodingScheme supportedCodingScheme = this.findCodingScheme(lexEvsVSD, cs);
CodeSystemReference codingSchemeRef =
this.getTransformUtils()
.toCodeSystemReference(
supportedCodingScheme.getLocalId(), supportedCodingScheme.getUri());
ref.setCodeSystem(codingSchemeRef);
ref.setTransitivity(
entityReference.getTransitiveClosure()
? TransitiveClosure.TRANSITIVE_CLOSURE
: TransitiveClosure.DIRECTLY_ASSOCIATED);
ref.setLeafOnly(
entityReference.getLeafOnly() ? LeafOrAll.LEAF_ONLY : LeafOrAll.ALL_INTERMEDIATE_NODES);
String association = entityReference.getReferenceAssociation();
PredicateReference predicate = new PredicateReference();
predicate.setName(association);
// namespace for a predicate is not guaranteed in LexEVS... not sure
// how we want to handle this. For now, assume the same namespace
// as the starting entity.
SupportedAssociation supportedAssociation =
this.findAssociation(lexEvsVSD.getMappings(), association);
if (supportedAssociation == null) {
predicate.setNamespace(supportedCodingScheme.getLocalId());
predicate.setUri(UriUtils.combine(supportedCodingScheme.getUri(), association));
} else {
predicate.setNamespace(supportedAssociation.getEntityCodeNamespace());
if (StringUtils.isNotBlank(supportedAssociation.getUri())) {
predicate.setUri(supportedAssociation.getUri());
} else {
predicate.setUri(UriUtils.combine(supportedCodingScheme.getUri(), association));
}
}
ref.setPredicate(predicate);
cts2Entry.setAssociatedEntities(ref);
} else {
SpecificEntityList sel = new SpecificEntityList();
sel.addReferencedEntity(uriAndName);
cts2Entry.setEntityList(sel);
}
}