public ConformanceBuilderTests()
 {
     _searchParameterDefinitionManager = Substitute.For <ISearchParameterDefinitionManager>();
     _builder = CapabilityStatementBuilder.Create(
         ModelInfoProvider.Instance,
         _searchParameterDefinitionManager);
 }
        public void GivenAConformanceBuilder_WhenVersionofResourceIsDifferentFromDefault_ThenResourceUsesResourceSpecificVersionLogic()
        {
            IOptions <CoreFeatureConfiguration> configuration = Substitute.For <IOptions <CoreFeatureConfiguration> >();
            Dictionary <string, string>         overrides     = new();
            VersioningConfiguration             versionConfig = new();

            versionConfig.ResourceTypeOverrides.Add("Patient", "no-version");

            configuration.Value.Returns(new CoreFeatureConfiguration()
            {
                Versioning = versionConfig
            });
            var supportedProfiles = Substitute.For <IKnowSupportedProfiles>();
            var builder           = CapabilityStatementBuilder.Create(
                ModelInfoProvider.Instance,
                _searchParameterDefinitionManager,
                configuration,
                supportedProfiles);
            ICapabilityStatementBuilder capabilityStatement = builder.ApplyToResource("Patient", c =>
            {
                c.Interaction.Add(new ResourceInteractionComponent
                {
                    Code = "create",
                });
            });
            ITypedElement resource = capabilityStatement.Build();

            var patientResource = ((CapabilityStatement)resource.ToPoco()).Rest.First().Resource.First();

            Assert.True(patientResource.Type == ResourceType.Patient);
            Assert.True(patientResource.Versioning == CapabilityStatement.ResourceVersionPolicy.NoVersion);
        }
        public CapabilityStatement CreateMetadata(ICollection <IFhirService> services, AbstractStructureDefinitionService abstractStructureDefinitionService, string baseUrl)
        {
            if (!services.Any())
            {
                return(new CapabilityStatement());
            }
            var serviceName = MetaDataName(services);

            var fhirVersion = ModelInfo.Version;

            var fhirPublisher   = GetFhirPublisher();
            var fhirDescription = GetFhirDescription();

            var conformance = CapabilityStatementBuilder.CreateServer(serviceName, fhirPublisher, fhirVersion);

            //conformance.AddUsedResources(services, false, false,
            //  CapabilityStatement.ResourceVersionPolicy.VersionedUpdate);

            //conformance.AddSearchSetInteraction().AddSearchTypeInteractionForResources();
            conformance.AddSearchTypeInteractionForResources();
            conformance = conformance.AddCoreSearchParamsAllResources(services);
            conformance = conformance.AddOperationDefintion(services);

            conformance.AcceptUnknown = CapabilityStatement.UnknownContentCode.Both;
            conformance.Experimental  = true;
            conformance.Format        = new[] { "xml", "json" };
            conformance.Description   = new Markdown(fhirDescription);

            conformance.Profile = SetProfiles(abstractStructureDefinitionService);

            return(conformance);
        }
        public ConformanceBuilderTests()
        {
            IOptions <CoreFeatureConfiguration> configuration = Substitute.For <IOptions <CoreFeatureConfiguration> >();

            configuration.Value.Returns(new CoreFeatureConfiguration());

            _searchParameterDefinitionManager = Substitute.For <ISearchParameterDefinitionManager>();
            _supportedProfiles = Substitute.For <IKnowSupportedProfiles>();
            _builder           = CapabilityStatementBuilder.Create(
                ModelInfoProvider.Instance,
                _searchParameterDefinitionManager,
                configuration,
                _supportedProfiles);
        }
Beispiel #5
0
        public static CapabilityStatement CreateMetaData(IEnumerable <IFhirService> services, IConfigurationRoot appSettings, HttpRequest request)
        {
            var enumerableFhirServices = services as IFhirService[] ?? services.ToArray();
            var fhirServices           = services as IFhirService[] ?? enumerableFhirServices.ToArray();

            if (!fhirServices.Any())
            {
                return(new CapabilityStatement());
            }

            var serviceName = MetaDataName(fhirServices);
            var fhirVersion = GetFhirVersion(ModelInfo.Version);

            var publisher           = GetFhirStarterSettingString(appSettings, "FhirPublisher");
            var capabilityStatement =
                CapabilityStatementBuilder.CreateServer(serviceName, publisher, fhirVersion);

            capabilityStatement.AddSearchTypeInteractionForResources();
            capabilityStatement = capabilityStatement.AddCoreSearchParamsAllResources(enumerableFhirServices);
            //  capabilityStatement = capabilityStatement.AddOperationDefinition(enumerableFhirServices, request);

            capabilityStatement.Experimental = false;
            capabilityStatement.Format       = new List <string> {
                "xml+fhir", "json+fhir"
            };

            var fhirDescription = GetFhirStarterSettingString(appSettings, "FhirDescription");

            if (!string.IsNullOrEmpty(fhirDescription))
            {
                capabilityStatement.Description = new Markdown(fhirDescription);
            }

            capabilityStatement.Rest =
                AddProfile(capabilityStatement.Rest, enumerableFhirServices);

            return(capabilityStatement);
        }