public static ElementDefinition.ElementDefinitionBindingComponent SetBinding(this ElementDefinition elementDefinition,
                                                                                     BindingStrength strength,
                                                                                     String name,
                                                                                     String description,
                                                                                     String valueSet)
        {
            if (elementDefinition == null)
            {
                throw new ArgumentNullException(nameof(elementDefinition));
            }

            elementDefinition.Binding = new ElementDefinition.ElementDefinitionBindingComponent
#else           // default
        Invalid fhir type
#endif
            {
                Strength    = strength,
                Description = description,
#if FHIR_R3
                ValueSet = new FhirUri(valueSet),
#elif FHIR_R4
                ValueSet = valueSet,
#else           // default
                Invalid fhir type
#endif
            };
            elementDefinition.Binding.AddExtension(@"http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName", new FhirString(name));
            return(elementDefinition.Binding);
        }
        public static ElementDefinition.ElementDefinitionBindingComponent SetBinding(this ElementDefinition elementDefinition,
                                                                                     BindingStrength strength,
                                                                                     String name,
                                                                                     String description,
                                                                                     String valueSet)
        {
            if (elementDefinition is null)
            {
                throw new ArgumentNullException(nameof(elementDefinition));
            }

            elementDefinition.Binding = new ElementDefinition.ElementDefinitionBindingComponent
Beispiel #3
0
        public static ElementDefinition WithBinding(this ElementDefinition ed, string valueSetUri, BindingStrength strength)
        {
            var binding = new ElementDefinition.BindingComponent
            {
                ValueSet = new ResourceReference(valueSetUri),
                Strength = strength
            };

            ed.Binding = binding;

            return(ed);
        }
Beispiel #4
0
        public ElementTreeSlice ComponentSliceCodeableConcept(String sliceName,
                                                              CodeableConcept pattern,
                                                              ValueSet valueSet,
                                                              BindingStrength bindingStrength,
                                                              Int32 minCardinality,
                                                              String maxCardinality,
                                                              String componentName,
                                                              String sliceDefinitionText,
                                                              Modalities modalities = Modalities.All)
        {
            String   compStr = maxCardinality == "1" ? compStr = "component" : "components";
            Markdown sliceDefinition;

            {
                String introStr;
                if (minCardinality == 0)
                {
                    if (maxCardinality == "1")
                    {
                        introStr = "This slice contains the optional component";
                    }
                    else
                    {
                        introStr = "This slice contains the optional components";
                    }
                }
                else
                {
                    if (maxCardinality == "1")
                    {
                        introStr = "This slice contains the required component";
                    }
                    else
                    {
                        introStr = "This slice contains the required components";
                    }
                }

                sliceDefinition = new Markdown()
                                  .Paragraph($"{introStr} that {sliceDefinitionText}.",
                                             $"The value of this component is a codeable concept chosen from the {valueSet.Name} valueset.");
            }

            ElementTreeSlice slice = this.AppendSlice("component", sliceName, minCardinality, maxCardinality);

            slice.ElementDefinition
            .SetShort($"{componentName} component.")
            .SetDefinition(sliceDefinition)
            .SetComment(ResourcesMaker.componentDefinition)
            ;

            if (modalities != Modalities.All)
            {
                slice.ElementDefinition.Definition
                .ValidModalities(modalities);
            }

            if (String.IsNullOrWhiteSpace(pattern.Coding[0].Display))
            {
                throw new Exception($"Display null on coding {pattern.Coding[0].Code}");
            }
            {
                ElementDefinition componentCode = new ElementDefinition
                {
                    Path       = $"{slice.ElementDefinition.Path}.code",
                    ElementId  = $"{slice.ElementDefinition.Path}:{sliceName}.code",
                    Min        = 1,
                    Max        = "1",
                    Short      = $"{componentName} component code",
                    Definition = new Markdown()
                                 .Paragraph($"This code identifies the {componentName} {compStr}.",
                                            $"Its value shall always be the concept '{pattern.Coding[0].Display}'")
                };
                componentCode
                .Pattern(pattern.ToPattern())
                .DefaultValueExtension(pattern)
                ;
                slice.CreateNode(componentCode);
            }
            {
                ElementDefinition valueX = new ElementDefinition
                {
                    Path      = $"{slice.ElementDefinition.Path}.value[x]",
                    ElementId = $"{slice.ElementDefinition.Path}:{sliceName}.value[x]",
                    Min       = 1,
                    Max       = "1",
                    Short     = $"{componentName} component value",
                };
                valueX
                .Binding(valueSet, bindingStrength)
                .Type("CodeableConcept")
                .SetDefinition(new Markdown()
                               .Paragraph("Value is a codeable concept.")
                               )
                ;
                slice.CreateNode(valueX);
            }

            String componentRef = Global.ElementAnchor(slice.ElementDefinition);

            this.AddComponentLink(componentName,
                                  new SDefEditor.Cardinality(slice.ElementDefinition),
                                  null,
                                  componentRef,
                                  "CodeableConcept",
                                  valueSet.Url);

            return(slice);
        }