public XElement generate(ValueSet vs)
{
var result = new XElement(XmlNs.XHTMLNS + "div");
if (vs.Expansion != null)
{
if (vs.Define == null && vs.Compose == null)
{
throw new NotImplementedException("Expansion HTML generation not yet supported");
//generateExpansion(x, vs);
}
else
throw new Exception("Error: should not encounter value set expansion at this point");
}
bool hasExtensions = false;
if (vs.Define != null)
hasExtensions = generateDefinition(result, vs);
if (vs.Compose != null)
hasExtensions = generateComposition(result, vs) || hasExtensions;
//inject(vs, result, hasExtensions ? NarrativeStatus.EXTENSIONS : NarrativeStatus.GENERATED);
return result;
}
public ValueSet HarvestValueSet(Hl7.Fhir.Model.ValueSet source)
{
ValueSet valueset = new ValueSet();
// todo: This now only works with "defines".
if (source.Define != null)
{
foreach (var concept in source.Define.Concept)
{
valueset.codes.Add(concept.Code);
}
}
return(valueset);
}
private bool generateDefinition(XElement x, ValueSet vs)
{
bool hasExtensions = false;
var mymaps = new Dictionary<ConceptMap, String>();
//TODO: Add ConceptMap infrastructure
//for (AtomEntry<ConceptMap> a : context.getMaps().values())
//{
// if (((Reference) a.getResource().getSource()).getReference().equals(vs.getIdentifier()))
// {
// String url = "";
// if (context.getValueSets().containsKey(((Reference) a.getResource().getTarget()).getReference()))
// url = context.getValueSets().get(((Reference) a.getResource().getTarget()).getReference()).getLinks().get("path");
// mymaps.put(a.getResource(), url);
// }
//}
var langs = new List<String>();
x.Add(new XElement(XmlNs.XHTMLNS + "h2"), new XText("Value Set for codes in " + vs.Name));
var p = new XElement(XmlNs.XHTMLNS + "p");
smartAddText(p, vs.Description);
x.Add(p);
if (vs.Copyright != null) generateCopyright(x, vs);
x.Add(new XElement(XmlNs.XHTMLNS + "p", "This value set defines its own terms in the system " + vs.Define.System));
var t = new XElement(XmlNs.XHTMLNS + "table", new XAttribute("class", "codes"));
x.Add(t);
bool commentS = false;
bool deprecated = false;
if (vs.Define.Concept != null)
{
// foreach (var c in vs.Define.Concept)
// {
// commentS = commentS || conceptsHaveComments(c);
// deprecated = deprecated || conceptsHaveDeprecated(c);
// scanLangs(c, langs);
// }
//addMapHeaders(addTableHeaderRowStandard(t, commentS, deprecated), mymaps); replaced by next line:
addTableHeaderRowStandard(t, commentS, deprecated);
foreach (var c in vs.Define.Concept)
hasExtensions = addDefineRowToTable(t, c, 0, commentS, deprecated, mymaps) || hasExtensions;
}
//TODO: Add language infrastructure
//if (langs.size() > 0)
//{
// Collections.sort(langs);
// x.addTag("p").addTag("b").addText("Additional Language Displays");
// t = x.addTag("table").setAttribute("class", "codes");
// XhtmlNode tr = t.addTag("tr");
// tr.addTag("td").addTag("b").addText("Code");
// for (String lang : langs)
// tr.addTag("td").addTag("b").addText(lang);
// for (ConceptDefinitionComponent c : vs.getDefine().getConcept())
// {
// addLanguageRow(c, t, langs);
// }
//}
return hasExtensions;
}
private String describe(ValueSet.FilterOperator opSimple)
{
switch (opSimple)
{
case ValueSet.FilterOperator.Equal: return " = ";
case ValueSet.FilterOperator.IsA: return " is-a ";
case ValueSet.FilterOperator.IsNotA: return " is-not-a ";
case ValueSet.FilterOperator.Regex: return " matches (by regex) ";
case ValueSet.FilterOperator.In: return " in ";
case ValueSet.FilterOperator.NotIn: return " not in ";
}
return null;
}
private void generateCopyright(XElement x, ValueSet vs)
{
var p = new XElement(XmlNs.XHTMLNS + "p", new XElement(XmlNs.XHTMLNS + "b", new XText("Copyright Statement:")));
smartAddText(p, " " + vs.Copyright);
x.Add(p);
}
private bool inConcept(String code, ValueSet.ValueSetDefineConceptComponent c)
{
if (c.Code == code)
return true;
foreach (var g in c.Concept)
{
if (inConcept(code, g))
return true;
}
return false;
}
private bool codeExistsInValueSet(ValueSet vs, String code)
{
if (vs.Define == null || vs.Define.Concept == null) return false;
foreach (var c in vs.Define.Concept)
{
if (inConcept(code, c))
return true;
}
return false;
}
/// <summary>
/// Parse ValueSet
/// </summary>
public static Hl7.Fhir.Model.ValueSet ParseValueSet(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.ValueSet existingInstance = null)
{
Hl7.Fhir.Model.ValueSet result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.ValueSet();
string currentElementName = reader.CurrentElementName;
reader.EnterElement();
while (reader.HasMoreElements())
{
var atName = reader.CurrentElementName;
// Parse element extension
if (atName == "extension")
{
result.Extension = new List <Hl7.Fhir.Model.Extension>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "extension"))
{
result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
}
reader.LeaveArray();
}
// Parse element language
else if (atName == "language")
{
result.LanguageElement = CodeParser.ParseCode(reader, errors);
}
// Parse element text
else if (atName == "text")
{
result.Text = NarrativeParser.ParseNarrative(reader, errors);
}
// Parse element contained
else if (atName == "contained")
{
result.Contained = new List <Hl7.Fhir.Model.Resource>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "contained"))
{
result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
}
reader.LeaveArray();
}
// Parse element _id
else if (atName == "_id")
{
result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
}
// Parse element identifier
else if (atName == "identifier")
{
result.IdentifierElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element version
else if (atName == "version")
{
result.VersionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element name
else if (atName == "name")
{
result.NameElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element publisher
else if (atName == "publisher")
{
result.PublisherElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element telecom
else if (atName == "telecom")
{
result.Telecom = new List <Hl7.Fhir.Model.Contact>();
reader.EnterArray();
while (ParserUtils.IsAtArrayElement(reader, "telecom"))
{
result.Telecom.Add(ContactParser.ParseContact(reader, errors));
}
reader.LeaveArray();
}
// Parse element description
else if (atName == "description")
{
result.DescriptionElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element copyright
else if (atName == "copyright")
{
result.CopyrightElement = FhirStringParser.ParseFhirString(reader, errors);
}
// Parse element status
else if (atName == "status")
{
result.StatusElement = CodeParser.ParseCode <Hl7.Fhir.Model.ValueSet.ValueSetStatus>(reader, errors);
}
// Parse element experimental
else if (atName == "experimental")
{
result.ExperimentalElement = FhirBooleanParser.ParseFhirBoolean(reader, errors);
}
// Parse element date
else if (atName == "date")
{
result.DateElement = FhirDateTimeParser.ParseFhirDateTime(reader, errors);
}
// Parse element define
else if (atName == "define")
{
result.Define = ValueSetParser.ParseValueSetDefineComponent(reader, errors);
}
// Parse element compose
else if (atName == "compose")
{
result.Compose = ValueSetParser.ParseValueSetComposeComponent(reader, errors);
}
// Parse element expansion
else if (atName == "expansion")
{
result.Expansion = ValueSetParser.ParseValueSetExpansionComponent(reader, errors);
}
else
{
errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
reader.SkipSubElementsFor(currentElementName);
result = null;
}
}
reader.LeaveElement();
return(result);
}
private ValueSet.ValueSetDefineConceptComponent getConceptForCode(ValueSet vs, String code, String system)
{
if (vs == null)
{
//TODO: include additional terminology services
//if (context.getTerminologyServices() != null)
// return context.getTerminologyServices().getCodeDefinition(system, code);
//else
return null;
}
if (vs.Define == null)
return null;
foreach (var c in vs.Define.Concept)
{
var v = getConceptForCode(c, code);
if (v != null)
return v;
}
return null;
}
private void addCsRef(ValueSet.ConceptSetComponent inc, XElement li, ValueSet cs)
{
String reference = null;
if (cs != null)
{
reference = inc.System;
}
if (cs != null && reference != null)
{
if (!String.IsNullOrEmpty(prefix) && reference.StartsWith("http://hl7.org/fhir/"))
reference = reference.Substring(20)+"/index.html";
XElement a =new XElement(XmlNs.XHTMLNS+"a"); li.Add(a);
a.Add(new XAttribute("href", prefix+reference.Replace("\\", "/")));
a.Add(new XText(inc.System));
}
else
li.Add(new XText(inc.System));
}
private bool genInclude(XElement ul, ValueSet.ConceptSetComponent inc, String type)
{
bool hasExtensions = false;
var li = new XElement(XmlNs.XHTMLNS + "li"); ul.Add(li);
var e = _pkp.GetValueSetForSystem(inc.System);
// AtomEntry<? extends Resource> e = context.getCodeSystems().get(inc.getSystem());
if ( (inc.Code == null || !inc.Code.Any()) && (inc.Filter == null || !inc.Filter.Any()))
{
li.Add(new XText(type+" all codes defined in "));
addCsRef(inc, li, e);
}
else
{
if (inc.CodeElement != null && inc.CodeElement.Any())
{
li.Add(new XText(type+" these codes as defined in "));
addCsRef(inc, li, e);
var t = new XElement(XmlNs.XHTMLNS+"table"); li.Add(t);
bool hasComments = false;
foreach (var c in inc.CodeElement)
{
hasComments = hasComments || c.GetExtension(ToolingExtensions.EXT_COMMENT) != null;
}
if (hasComments)
hasExtensions = true;
addTableHeaderRowStandard(t, hasComments, false);
foreach(var c in inc.CodeElement)
{
var tr = new XElement(XmlNs.XHTMLNS + "tr"); t.Add(tr);
tr.Add(new XElement(XmlNs.XHTMLNS+"td", new XText(c.Value)));
ValueSet.ValueSetDefineConceptComponent cc = getConceptForCode(e, c.Value, inc.System);
XElement td = new XElement(XmlNs.XHTMLNS+"td"); tr.Add(td);
if (cc != null && !String.IsNullOrEmpty(cc.Display))
td.Add(new XText(cc.Display));
//if (!Utilities.noString(c.getDisplay())) DSTU2
// td.addText(c.getDisplay());
//else if (cc != null && !Utilities.noString(cc.getDisplay()))
// td.addText(cc.getDisplay());
td = new XElement(XmlNs.XHTMLNS+"td"); tr.Add(td);
if (c.GetExtension(ToolingExtensions.EXT_DEFINITION) != null)
smartAddText(td, ToolingExtensions.ReadStringExtension(c, ToolingExtensions.EXT_DEFINITION));
else if (cc != null && !String.IsNullOrEmpty(cc.Definition))
smartAddText(td, cc.Definition);
else
; // No else in the java code!!
if (c.GetExtension(ToolingExtensions.EXT_COMMENT) != null)
{
var tdn = new XElement(XmlNs.XHTMLNS+"td"); tr.Add(td);
smartAddText(tdn, "Note: "+ ToolingExtensions.ReadStringExtension(c, ToolingExtensions.EXT_COMMENT));
}
}
}
if (inc.Filter != null)
{
foreach (var f in inc.Filter)
{
li.Add(new XText(type + " codes from "));
addCsRef(inc, li, e);
// TODO: Java code does not allow for f.Op to be null, but it is optional
li.Add(new XText(" where " + f.Property + " " + describe(f.Op.GetValueOrDefault()) + " "));
if (e != null && codeExistsInValueSet(e, f.Value))
{
li.Add(new XElement(XmlNs.XHTMLNS + "a",
new XText(f.Value), new XAttribute("href", prefix + getCsRef(inc.System) + "#" + ProfileKnowledgeProvider.TokenizeName(f.Value))));
}
else
li.Add(new XText(f.Value));
String disp = f.getDisplayHint();
if (disp != null)
li.Add(new XText(" (" + disp + ")"));
}
}
}
return hasExtensions;
}
private bool generateComposition(XElement x, ValueSet vs)
{
bool hasExtensions = false;
if (vs.Define == null)
{
var h = new XElement(XmlNs.XHTMLNS + "h2", new XText("Value Set for codes in " + vs.Name));
var p = new XElement(XmlNs.XHTMLNS + "p");
smartAddText(p, vs.Description);
x.Add(h, p);
if (vs.Copyright != null)
generateCopyright(x, vs);
x.Add(new XElement(XmlNs.XHTMLNS + "p", "This value set includes codes defined in other code systems, using the following rules:"));
}
else
{
x.Add(new XElement(XmlNs.XHTMLNS + "p", "In addition, this value set includes codes defined in other code systems, using the following rules:"));
}
var ul = new XElement(XmlNs.XHTMLNS + "ul");
x.Add(ul);
XElement li;
if (vs.Compose.Import != null)
{
foreach (var imp in vs.Compose.Import)
{
li = new XElement(XmlNs.XHTMLNS + "li");
ul.Add(li);
li.Add(new XText("Import all the codes that are part of "));
AddVsRef(imp, li);
}
}
if (vs.Compose.Include != null)
{
foreach (var inc in vs.Compose.Include)
hasExtensions = genInclude(ul, inc, "Include") || hasExtensions;
}
if (vs.Compose.Exclude != null)
{
foreach (var exc in vs.Compose.Exclude)
hasExtensions = genInclude(ul, exc, "Exclude") || hasExtensions;
}
return hasExtensions;
}
private bool addDefineRowToTable(XElement t, ValueSet.ValueSetDefineConceptComponent c, int i, bool comment, bool deprecated, Dictionary<ConceptMap, String> maps)
{
bool hasExtensions = false;
XElement tr = new XElement(XmlNs.XHTMLNS + "tr"); t.Add(tr);
XElement td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
var indent = new String('.', i * 2);
td.Add(new XText(indent + c.Code));
td.Add(new XElement(XmlNs.XHTMLNS + "a", new XAttribute("name", ProfileKnowledgeProvider.TokenizeName(c.Code)), new XText(" ")));
td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
if (c.Display != null) td.Add(new XText(c.Display));
td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
if (c.Definition != null) smartAddText(td, c.Definition);
if (deprecated)
{
td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
var s = c.GetDeprecated();
if (s != null)
{
smartAddText(td, s);
hasExtensions = true;
}
}
if (comment)
{
td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
var s = c.GetComment();
if (s != null)
{
smartAddText(td, s);
hasExtensions = true;
}
}
//for (ConceptMap m : maps.keySet())
//{
// td = tr.addTag("td");
// List<ConceptMapElementMapComponent> mappings = findMappingsForCode(c.getCode(), m);
// boolean first = true;
// for (ConceptMapElementMapComponent mapping : mappings)
// {
// if (!first)
// td.addTag("br");
// first = false;
// XhtmlNode span = td.addTag("span");
// span.setAttribute("title", mapping.getEquivalence().toString());
// span.addText(getCharForEquivalence(mapping));
// a = td.addTag("a");
// a.setAttribute("href", prefix+maps.get(m)+"#"+mapping.getCode());
// a.addText(mapping.getCode());
// if (!Utilities.noString(mapping.getComments()))
// td.addTag("i").addText("("+mapping.getComments()+")");
// }
//}
foreach (var e in c.GetSubsumes())
{
hasExtensions = true;
tr = new XElement(XmlNs.XHTMLNS + "tr"); t.Add(tr);
td = new XElement(XmlNs.XHTMLNS + "td"); tr.Add(td);
indent = new String('.', i * 2);
td.Add(new XText(indent));
var a = new XElement(XmlNs.XHTMLNS + "a");
a.Add(new XAttribute("href", "#" + ProfileKnowledgeProvider.TokenizeName(e.Value)));
a.Add(new XText(c.Code));
td.Add(a);
}
foreach (var cc in c.Concept)
{
hasExtensions = addDefineRowToTable(t, cc, i + 1, comment, deprecated, maps) || hasExtensions;
}
return hasExtensions;
}
public static void SerializeValueSet(Hl7.Fhir.Model.ValueSet value, IFhirWriter writer, bool summary)
{
writer.WriteStartRootObject("ValueSet");
writer.WriteStartComplexContent();
// Serialize element _id
if (value.LocalIdElement != null)
{
writer.WritePrimitiveContents("_id", value.LocalIdElement, XmlSerializationHint.Attribute);
}
// Serialize element extension
if (value.Extension != null && !summary && value.Extension.Count > 0)
{
writer.WriteStartArrayElement("extension");
foreach (var item in value.Extension)
{
writer.WriteStartArrayMember("extension");
ExtensionSerializer.SerializeExtension(item, writer, summary);
writer.WriteEndArrayMember();
}
writer.WriteEndArrayElement();
}
// Serialize element language
if (value.LanguageElement != null && !summary)
{
writer.WriteStartElement("language");
CodeSerializer.SerializeCode(value.LanguageElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element text
if (value.Text != null && !summary)
{
writer.WriteStartElement("text");
NarrativeSerializer.SerializeNarrative(value.Text, writer, summary);
writer.WriteEndElement();
}
// Serialize element contained
if (value.Contained != null && !summary && value.Contained.Count > 0)
{
writer.WriteStartArrayElement("contained");
foreach (var item in value.Contained)
{
writer.WriteStartArrayMember("contained");
FhirSerializer.SerializeResource(item, writer, summary);
writer.WriteEndArrayMember();
}
writer.WriteEndArrayElement();
}
// Serialize element identifier
if (value.IdentifierElement != null)
{
writer.WriteStartElement("identifier");
FhirStringSerializer.SerializeFhirString(value.IdentifierElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element version
if (value.VersionElement != null)
{
writer.WriteStartElement("version");
FhirStringSerializer.SerializeFhirString(value.VersionElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element name
if (value.NameElement != null)
{
writer.WriteStartElement("name");
FhirStringSerializer.SerializeFhirString(value.NameElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element publisher
if (value.PublisherElement != null)
{
writer.WriteStartElement("publisher");
FhirStringSerializer.SerializeFhirString(value.PublisherElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element telecom
if (value.Telecom != null && value.Telecom.Count > 0)
{
writer.WriteStartArrayElement("telecom");
foreach (var item in value.Telecom)
{
writer.WriteStartArrayMember("telecom");
ContactSerializer.SerializeContact(item, writer, summary);
writer.WriteEndArrayMember();
}
writer.WriteEndArrayElement();
}
// Serialize element description
if (value.DescriptionElement != null)
{
writer.WriteStartElement("description");
FhirStringSerializer.SerializeFhirString(value.DescriptionElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element copyright
if (value.CopyrightElement != null && !summary)
{
writer.WriteStartElement("copyright");
FhirStringSerializer.SerializeFhirString(value.CopyrightElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element status
if (value.StatusElement != null)
{
writer.WriteStartElement("status");
CodeSerializer.SerializeCode <Hl7.Fhir.Model.ValueSet.ValueSetStatus>(value.StatusElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element experimental
if (value.ExperimentalElement != null)
{
writer.WriteStartElement("experimental");
FhirBooleanSerializer.SerializeFhirBoolean(value.ExperimentalElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element date
if (value.DateElement != null)
{
writer.WriteStartElement("date");
FhirDateTimeSerializer.SerializeFhirDateTime(value.DateElement, writer, summary);
writer.WriteEndElement();
}
// Serialize element define
if (value.Define != null && !summary)
{
writer.WriteStartElement("define");
ValueSetSerializer.SerializeValueSetDefineComponent(value.Define, writer, summary);
writer.WriteEndElement();
}
// Serialize element compose
if (value.Compose != null && !summary)
{
writer.WriteStartElement("compose");
ValueSetSerializer.SerializeValueSetComposeComponent(value.Compose, writer, summary);
writer.WriteEndElement();
}
// Serialize element expansion
if (value.Expansion != null && !summary)
{
writer.WriteStartElement("expansion");
ValueSetSerializer.SerializeValueSetExpansionComponent(value.Expansion, writer, summary);
writer.WriteEndElement();
}
writer.WriteEndComplexContent();
writer.WriteEndRootObject();
}
private ValueSet.ValueSetDefineConceptComponent getConceptForCode(ValueSet.ValueSetDefineConceptComponent c, String code)
{
if (code == c.Code)
return c;
if (c.Concept == null) return null;
foreach (var cc in c.Concept)
{
var v = getConceptForCode(cc, code);
if (v != null)
return v;
}
return null;
}
private ValueSet BuildValueSet(Entities.ValueSetVersion valueSetVersionFromRepo, Entities.ValueSet valueSetFromRepo, bool includeConcepts = true)
{
var valueSet = new Hl7.Fhir.Model.ValueSet();
valueSet.Url = Url.Link(
nameof(GetVersionedValueSetById),
new
{
type = "ValueSet",
id = valueSetFromRepo.ValueSetCode,
vid = valueSetVersionFromRepo.ValueSetVersionNumber.ToString()
});
valueSet.Identifier = new List <Identifier>()
{
new Identifier()
{
Use = Identifier.IdentifierUse.Official,
Value = valueSetVersionFromRepo.ValueSetVersionID.ToString(),
System = "urn:ietf:rfc:3986"
},
new Identifier()
{
Use = Identifier.IdentifierUse.Secondary,
Value = valueSetVersionFromRepo.ValueSetOID
},
new Identifier()
{
Use = Identifier.IdentifierUse.Secondary,
Value = valueSetVersionFromRepo.ValueSetCode
}
};
valueSet.Name = valueSetFromRepo.ValueSetCode;
valueSet.Title = valueSetFromRepo.ValueSetName;
valueSet.Description = new Markdown(valueSetFromRepo.DefinitionText);
valueSet.Publisher = "PHIN_VADS";
valueSet.DateElement = new FhirDateTime(valueSetVersionFromRepo.StatusDate);
valueSet.Version = valueSetVersionFromRepo.ValueSetVersionNumber.ToString();
valueSet.VersionId = valueSetVersionFromRepo.ValueSetVersionID.ToString();
valueSet.Status = PublicationStatus.Active;
if (includeConcepts)
{
valueSet.Expansion = new ValueSet.ExpansionComponent()
{
Identifier = Guid.NewGuid().ToString(),
TimestampElement = new FhirDateTime(DateTimeOffset.Now),
Contains = new List <ValueSet.ContainsComponent>()
};
var paginationParameters = new ValueSetConceptPaginationParameters()
{
ValueSetVersionId = valueSetVersionFromRepo.ValueSetVersionID,
ValueSetVersionNumber = valueSetVersionFromRepo.ValueSetVersionNumber.ToString(),
PageSize = 1000
};
var valueSetConceptEntities = _valueSetConceptRepository.GetValueSetConcepts(paginationParameters);
foreach (var conceptFromRepo in valueSetConceptEntities)
{
var component = new ValueSet.ContainsComponent()
{
Code = conceptFromRepo.ConceptCode,
Display = conceptFromRepo.CDCPreferredDesignation,
System = $"urn:oid:{conceptFromRepo.CodeSystemOID}",
Extension = new List <Extension>()
{
new Extension()
{
Value = new FhirString(conceptFromRepo.HL70396Identifier)
}
}
};
valueSet.Expansion.Contains.Add(component);
}
valueSet.Expansion.Total = valueSet.Expansion.Contains.Count;
valueSet.Expansion.Offset = (paginationParameters.PageNumber - 1) * paginationParameters.PageSize;
}
return(valueSet);
}
public IEnumerable<ConceptMap> GetConceptMapsForSource(ValueSet source)
{
return GetConceptMapsForSource(source.Url);
}
