Beispiel #1
0
        public CapabilityStatement.RestComponent GetRestDefinition()
        {
            var resourceComponent = new CapabilityStatement.ResourceComponent
            {
                Type        = ResourceType.Resource,
                Profile     = "url for structure defintion",
                Interaction = new List <CapabilityStatement.ResourceInteractionComponent>
                {
                    new CapabilityStatement.ResourceInteractionComponent
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Create
                    },
                    new CapabilityStatement.ResourceInteractionComponent
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Read
                    },
                    new CapabilityStatement.ResourceInteractionComponent
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Update
                    },
                    new CapabilityStatement.ResourceInteractionComponent
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Delete
                    }
                },
                Versioning = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };
            var restComponent = new CapabilityStatement.RestComponent();

            restComponent.Resource.Add(resourceComponent);
            return(restComponent);
        }
        public static CapabilityStatement.ResourceComponent AddSearchType(CapabilityStatement.ResourceComponent resourcecomp)
        {
            var type        = CapabilityStatement.TypeRestfulInteraction.SearchType;
            var interaction = AddSingleResourceInteraction(resourcecomp, type);

            resourcecomp.Interaction.Add(interaction);
            return(resourcecomp);
        }
        public static CapabilityStatement AddSingleResourceComponent(this CapabilityStatement conformance, String resourcetype, Boolean readhistory, Boolean updatecreate, CapabilityStatement.ResourceVersionPolicy versioning, ResourceReference profile = null)
        {
            var resource = new CapabilityStatement.ResourceComponent();

            resource.Type         = Hacky.GetResourceTypeForResourceName(resourcetype);
            resource.Profile      = profile;
            resource.ReadHistory  = readhistory;
            resource.UpdateCreate = updatecreate;
            resource.Versioning   = versioning;
            conformance.Server().Resource.Add(resource);
            return(conformance);
        }
        public static CapabilityStatement.ResourceComponent AddAllResourceInteractions(
            CapabilityStatement.ResourceComponent resourcecomp)
        {
            foreach (CapabilityStatement.TypeRestfulInteraction type in Enum.GetValues(
                         typeof(CapabilityStatement.TypeRestfulInteraction)))
            {
                var interaction = AddSingleResourceInteraction(type);
                resourcecomp.Interaction.Add(interaction);
            }

            return(resourcecomp);
        }
        public static CapabilityStatement.ResourceComponent AddCoreSearchParamsResource(
            CapabilityStatement.ResourceComponent resourcecomp)
        {
            var parameters = ModelInfo.SearchParameters.Where(sp => sp.Resource == resourcecomp.Type.GetLiteral())
                             .Select(
                sp => new CapabilityStatement.SearchParamComponent
            {
                Name = sp.Name, Type = sp.Type, Documentation = sp.Description
            });

            resourcecomp.SearchParam.AddRange(parameters);
            return(resourcecomp);
        }
        public static CapabilityStatement AddSingleResourceComponent(this CapabilityStatement capabilityStatement, string resourcetype, bool readhistory, bool updatecreate, CapabilityStatement.ResourceVersionPolicy versioning, ResourceReference profile = null)
        {
            var resource = new CapabilityStatement.ResourceComponent
            {
                Type         = (ResourceType)Enum.Parse(typeof(ResourceType), resourcetype, true),
                Profile      = profile,
                ReadHistory  = readhistory,
                UpdateCreate = updatecreate,
                Versioning   = versioning
            };

            capabilityStatement.Server().Resource.Add(resource);
            return(capabilityStatement);
        }
        public static CapabilityStatement AddSingleResourceComponent(
            this CapabilityStatement capabilityStatement,
            string resourcetype,
            bool readhistory,
            bool updatecreate,
            CapabilityStatement.ResourceVersionPolicy versioning,
            Canonical profile = null)
        {
            var resource = new CapabilityStatement.ResourceComponent
            {
                Type         = Hacky.GetResourceTypeForResourceName(resourcetype),
                Profile      = profile,
                ReadHistory  = readhistory,
                UpdateCreate = updatecreate,
                Versioning   = versioning
            };

            capabilityStatement.Server().Resource.Add(resource);
            return(capabilityStatement);
        }
Beispiel #8
0
        public IResourceServiceOutcome GetServersConformanceResource(IRequestMeta RequestMeta)
        {
            if (RequestMeta == null)
            {
                throw new NullReferenceException("RequestMeta can not be null.");
            }
            if (RequestMeta.SearchParameterGeneric == null)
            {
                throw new NullReferenceException("SearchParameterGeneric can not be null.");
            }

            IResourceServiceOutcome         ServiceOperationOutcome        = IResourceServiceOutcomeFactory.CreateResourceServiceOutcome();
            ISearchParameterService         SearchService                  = ISearchParameterServiceFactory.CreateSearchParameterService();
            ISearchParametersServiceOutcome SearchParametersServiceOutcome = SearchService.ProcessBaseSearchParameters(RequestMeta.SearchParameterGeneric);

            if (SearchParametersServiceOutcome.FhirOperationOutcome != null)
            {
                ServiceOperationOutcome.ResourceResult = SearchParametersServiceOutcome.FhirOperationOutcome;
                ServiceOperationOutcome.HttpStatusCode = SearchParametersServiceOutcome.HttpStatusCode;
                ServiceOperationOutcome.FormatMimeType = SearchParametersServiceOutcome.SearchParameters.Format;
                return(ServiceOperationOutcome);
            }

            var    Conformance            = new CapabilityStatement();
            var    ApplicationReleaseDate = new DateTimeOffset(2017, 10, 17, 6, 00, 00, new TimeSpan(8, 0, 0));
            string ServerName             = "Pyro Server";
            string Https = "https://";

            Conformance.Id               = "metadata";
            Conformance.Url              = $"{Https}{IPrimaryServiceRootCache.GetPrimaryRootUrlFromDatabase().Url}/metadata";
            Conformance.Version          = $"V{IGlobalProperties.ApplicationVersionInfo}";
            Conformance.Meta             = new Meta();
            Conformance.Meta.LastUpdated = ApplicationReleaseDate;
            Conformance.Name             = ServerName;
            Conformance.Status           = PublicationStatus.Active;
            Conformance.Experimental     = true;
            Conformance.Date             = (new FhirDateTime(ApplicationReleaseDate)).Value;
            Conformance.Publisher        = "PyroHealth.net";
            var AngusContactDetail = Common.PyroHealthInformation.PyroHealthContactDetailAngusMillar.GetContactDetail();

            Conformance.Contact = new List <ContactDetail>()
            {
                AngusContactDetail
            };

            Conformance.Description = new Markdown("Conformance statement for the " + ServerName);

            var Australia = new CodeableConcept("urn:iso:std:iso:3166", "AU", "Australia");

            Conformance.Jurisdiction = new List <CodeableConcept>()
            {
                Australia
            };

            Conformance.Purpose = new Markdown("FHIR Server reference implementation");

            Conformance.Copyright = new Markdown("Copyright: PyroHealth.net");
            Conformance.Kind      = CapabilityStatement.CapabilityStatementKind.Instance;

            Conformance.Software             = new CapabilityStatement.SoftwareComponent();
            Conformance.Software.Name        = ServerName;
            Conformance.Software.Version     = IGlobalProperties.ApplicationVersionInfo; //To align with FHIR version only use number no prefix of 'V'
            Conformance.Software.ReleaseDate = (new FhirDateTime(ApplicationReleaseDate)).Value;

            Conformance.Implementation             = new CapabilityStatement.ImplementationComponent();
            Conformance.Implementation.Description = $"{ServerName} is an implementation of a FHIR server supporting V{Hl7.Fhir.Model.ModelInfo.Version} of the specification. This instance is a publicly available testing server and its resource may be cleared at any time.";
            Conformance.Implementation.Url         = $"{Https}{IPrimaryServiceRootCache.GetPrimaryRootUrlFromDatabase().Url}";

            Conformance.FhirVersion   = Hl7.Fhir.Model.ModelInfo.Version; //Must be formated as just the number '3.0.1' as touchstone does not like the V3.0.1
            Conformance.AcceptUnknown = CapabilityStatement.UnknownContentCode.Extensions;

            var ContentFormatList = new List <string>();

            foreach (var mediaType in Hl7.Fhir.Rest.ContentType.XML_CONTENT_HEADERS)
            {
                ContentFormatList.Add(mediaType);
            }
            foreach (var mediaType in Hl7.Fhir.Rest.ContentType.JSON_CONTENT_HEADERS)
            {
                ContentFormatList.Add(mediaType);
            }
            Conformance.Format = ContentFormatList;

            Conformance.Rest = new List <CapabilityStatement.RestComponent>();
            var RestComponent = new CapabilityStatement.RestComponent();

            Conformance.Rest.Add(RestComponent);
            RestComponent.Mode                 = CapabilityStatement.RestfulCapabilityMode.Server;
            RestComponent.Documentation        = $"STU{Hl7.Fhir.Model.ModelInfo.Version.Split('.')[0]} V{Hl7.Fhir.Model.ModelInfo.Version} FHIR Server";
            RestComponent.Security             = new CapabilityStatement.SecurityComponent();
            RestComponent.Security.Description = "No Security has been implemented, server if publicly open";

            RestComponent.Interaction = new List <CapabilityStatement.SystemInteractionComponent>();
            var SystemInteractionComponent = new CapabilityStatement.SystemInteractionComponent();

            RestComponent.Interaction.Add(SystemInteractionComponent);
            SystemInteractionComponent.Code          = CapabilityStatement.SystemRestfulInteraction.Transaction;
            SystemInteractionComponent.Documentation = "Batch Transaction supports all request methods (Delete, POST, PUT, GET) including conditional create/update/delete. Operatons are not supported within Transaction bundles.";

            var CompartmentList = IServiceCompartmentRepository.GetAllServiceCompartments();

            if (CompartmentList != null && CompartmentList.Count > 0)
            {
                var CompartmentUrlList = new List <string>();
                CompartmentList.ForEach(x => CompartmentUrlList.Add(x.Url));
                RestComponent.Compartment = CompartmentUrlList;
            }

            RestComponent.Resource = new List <CapabilityStatement.ResourceComponent>();

            List <DtoServiceSearchParameterHeavy> DtoServiceSearchParameterHeavyList = IServiceSearchParameterService.GetServiceSearchParametersHeavy(false);

            var ResourceTypeList = Enum.GetValues(typeof(ResourceType));

            foreach (ResourceType ResourceType in ResourceTypeList)
            {
                string       CurrentResourceString = ResourceType.GetLiteral();
                FHIRAllTypes?FhirType          = Hl7.Fhir.Model.ModelInfo.FhirTypeNameToFhirType(CurrentResourceString);
                var          ResourceComponent = new CapabilityStatement.ResourceComponent();
                RestComponent.Resource.Add(ResourceComponent);
                ResourceComponent.Type        = ResourceType;
                ResourceComponent.Interaction = new List <CapabilityStatement.ResourceInteractionComponent>()
                {
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Create
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Delete
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Read
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Update
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.Vread
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.SearchType
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.HistoryInstance
                    },
                    new CapabilityStatement.ResourceInteractionComponent()
                    {
                        Code = CapabilityStatement.TypeRestfulInteraction.HistoryType
                    }
                    //new Conformance.ResourceInteractionComponent() { Code = Conformance.TypeRestfulInteraction.HistoryType},
                };
                ResourceComponent.Versioning        = CapabilityStatement.ResourceVersionPolicy.Versioned;
                ResourceComponent.ReadHistory       = true;
                ResourceComponent.UpdateCreate      = true;
                ResourceComponent.ConditionalCreate = true;
                ResourceComponent.ConditionalRead   = CapabilityStatement.ConditionalReadStatus.FullSupport;
                ResourceComponent.ConditionalUpdate = true;
                ResourceComponent.ConditionalDelete = CapabilityStatement.ConditionalDeleteStatus.Multiple;


                var ReferenceHandlingPolicyList = new List <CapabilityStatement.ReferenceHandlingPolicy?>();
                ReferenceHandlingPolicyList.Add(CapabilityStatement.ReferenceHandlingPolicy.Literal);
                ReferenceHandlingPolicyList.Add(CapabilityStatement.ReferenceHandlingPolicy.Local);
                ResourceComponent.ReferencePolicy = ReferenceHandlingPolicyList;

                List <DtoServiceSearchParameterHeavy> DtoServiceSearchParameterHeavyForResourceList = DtoServiceSearchParameterHeavyList.Where(x => x.Resource == CurrentResourceString || x.Resource == FHIRAllTypes.Resource.GetLiteral()).ToList();

                //List<ServiceSearchParameterHeavy> DtoServiceSearchParameterHeavyForResourceList = ICommonServices.GetServiceSearchParametersHeavyForResource(FhirType.Value.GetLiteral());
                //DtoServiceSearchParameterHeavyForResourceList.AddRange(ICommonServices.GetServiceSearchParametersHeavyForResource(FHIRAllTypes.Resource.GetLiteral()));
                ResourceComponent.SearchParam = new List <CapabilityStatement.SearchParamComponent>();
                List <string> IncludesList    = null;
                List <string> RevIncludesList = null;
                foreach (var SupportedSearchParam in DtoServiceSearchParameterHeavyForResourceList)
                {
                    if (SupportedSearchParam.IsIndexed && SupportedSearchParam.Status == PublicationStatus.Active)
                    {
                        //Include (RevIncludes are below)
                        if (SupportedSearchParam.Type == SearchParamType.Reference)
                        {
                            if (IncludesList == null)
                            {
                                IncludesList = new List <string>();
                            }
                            if (SupportedSearchParam.TargetResourceTypeList.Count > 1)
                            {
                                foreach (var Target in SupportedSearchParam.TargetResourceTypeList)
                                {
                                    IncludesList.Add($"{SupportedSearchParam.Resource}:{SupportedSearchParam.Name}:{Target.ResourceType.GetLiteral()}");
                                }
                            }
                            else
                            {
                                IncludesList.Add($"{SupportedSearchParam.Resource}:{SupportedSearchParam.Name}");
                            }
                        }

                        CapabilityStatement.SearchParamComponent SearchParamComponent = new CapabilityStatement.SearchParamComponent();
                        ResourceComponent.SearchParam.Add(SearchParamComponent);

                        SearchParamComponent.Name       = SupportedSearchParam.Name;
                        SearchParamComponent.Type       = SupportedSearchParam.Type;
                        SearchParamComponent.Definition = SupportedSearchParam.Url;
                        if (!string.IsNullOrWhiteSpace(SupportedSearchParam.Description))
                        {
                            SearchParamComponent.Documentation = SupportedSearchParam.Description;
                        }
                    }
                }
                ResourceComponent.SearchInclude = IncludesList;

                //RevIncludes
                var RevIncludeSearchParameterList = DtoServiceSearchParameterHeavyList.Where(x => x.Type == SearchParamType.Reference && x.TargetResourceTypeList.Any(c => c.ResourceType == ResourceType));
                foreach (var Rev in RevIncludeSearchParameterList)
                {
                    if (RevIncludesList == null)
                    {
                        RevIncludesList = new List <string>();
                    }
                    if (Rev.TargetResourceTypeList.Count > 1)
                    {
                        RevIncludesList.Add($"{Rev.Resource}:{Rev.Name}:{CurrentResourceString}");
                    }
                    else
                    {
                        RevIncludesList.Add($"{Rev.Resource}:{Rev.Name}");
                    }
                }

                ResourceComponent.SearchRevInclude = RevIncludesList;
            }
            ConstructConformanceResourceNarrative(Conformance);

            IDatabaseOperationOutcome DatabaseOperationOutcome = IDatabaseOperationOutcomeFactory.CreateDatabaseOperationOutcome();

            ServiceOperationOutcome.FhirResourceId        = Conformance.Id;
            ServiceOperationOutcome.ResourceVersionNumber = Conformance.Version;
            ServiceOperationOutcome.LastModified          = Conformance.Meta.LastUpdated;
            ServiceOperationOutcome.OperationType         = Common.Enum.RestEnum.CrudOperationType.Read;
            ServiceOperationOutcome.IsDeleted             = false;
            ServiceOperationOutcome.RequestUri            = null;
            ServiceOperationOutcome.ResourceResult        = Conformance;
            ServiceOperationOutcome.FormatMimeType        = SearchParametersServiceOutcome.SearchParameters.Format;
            ServiceOperationOutcome.HttpStatusCode        = System.Net.HttpStatusCode.OK;
            return(ServiceOperationOutcome);
        }
        public static CapabilityStatement.ResourceInteractionComponent AddSingleResourceInteraction(CapabilityStatement.ResourceComponent resourcecomp, CapabilityStatement.TypeRestfulInteraction type)
        {
            var interaction = new CapabilityStatement.ResourceInteractionComponent();

            interaction.Code = type;
            return(interaction);
        }
        public static CapabilityStatement Intersect(this ListedCapabilityStatement system, CapabilityStatement configured, bool strictConfig)
        {
            EnsureArg.IsNotNull(system, nameof(system));
            EnsureArg.IsNotNull(configured, nameof(configured));

            var issues = new List <string>();

            var intersecting = new CapabilityStatement
            {
                // System wide values
                Id           = system.Id,
                Url          = system.Url?.OriginalString,
                Version      = system.Version,
                Name         = system.Name,
                Experimental = system.Experimental,
                Publisher    = system.Publisher,
                Software     = system.Software,
                FhirVersion  = system.FhirVersion,
                Contact      = new List <ContactDetail> {
                    new ContactDetail {
                        Telecom = system.Telecom?.Select(x => new ContactPoint(x.System, x.Use, x.Value)).ToList()
                    }
                },

                // Intersections with user configured values
                Kind          = system.Kind.IntersectEnum(configured.Kind, issues, "Kind"),
                Status        = system.Status.IntersectEnum(configured.Status, issues, "Status"),
                AcceptUnknown = system.AcceptUnknown.IntersectEnum(configured.AcceptUnknown, issues, "AcceptUknown"),
                Format        = system.Format?.IntersectList(configured.Format, x => x, issues, "Format"),
            };

            DateTimeOffset cDate;

            if (DateTimeOffset.TryParse(configured.Date, out cDate))
            {
                intersecting.Date = cDate.ToString("o", CultureInfo.InvariantCulture);
            }

            if (system.Rest.Any() && configured.Rest.Any())
            {
                // Only a single rest node is currently supported
                if (system.Rest.Count() > 1 || configured.Rest.Count > 1)
                {
                    throw new NotSupportedException(Core.Resources.CapabilityStatementSingleRestItem);
                }

                var systemRest     = system.Rest.Single();
                var configuredRest = configured.Rest.Single();

                var rest = new CapabilityStatement.RestComponent
                {
                    Mode          = systemRest.Mode.IntersectEnum(configuredRest.Mode, issues, "Rest.Mode"),
                    Documentation = systemRest.Documentation,
                    Security      = systemRest.Security,
                    Interaction   = systemRest.Interaction?.IntersectList(configuredRest.Interaction, x => x.Code, issues, $"Rest.Interaction"),
                    SearchParam   = systemRest.SearchParam?.IntersectList(configuredRest.SearchParam, x => x.Name, issues, $"Rest.SearchParam"),
                    Operation     = systemRest.Operation?.IntersectList(configuredRest.Operation, x => x.Name, issues, $"Rest.Operation"),
                };

                intersecting.Rest.Add(rest);

                var systemComponents = systemRest.Resource.Where(x => configuredRest.Resource.Select(r => r.Type).Contains(x.Type));
                foreach (var systemComponent in systemComponents)
                {
                    var configuredComponent = configuredRest.Resource.Single(x => x.Type == systemComponent.Type);

                    // If the system has been set to support include, then build the possible include params from the search parameters
                    if (system.SupportsInclude)
                    {
                        systemComponent.SearchInclude = systemComponent.SearchParam.Where(sp => sp.Type == SearchParamType.Reference).Select(sp => $"{systemComponent.Type.ToString()}.{sp.Name}").ToList();
                    }

                    var interaction = new CapabilityStatement.ResourceComponent
                    {
                        // System predefined values
                        Type = systemComponent.Type,

                        // User configurable override
                        Profile = configuredComponent.Profile ?? systemComponent.Profile,

                        // Boolean intersections
                        ReadHistory       = systemComponent.ReadHistory.IntersectBool(configuredComponent.ReadHistory, issues, $"Rest.Resource['{systemComponent.Type}'].ReadHistory"),
                        UpdateCreate      = systemComponent.UpdateCreate.IntersectBool(configuredComponent.UpdateCreate, issues, $"Rest.Resource['{systemComponent.Type}'.UpdateCreate"),
                        ConditionalCreate = systemComponent.ConditionalCreate.IntersectBool(configuredComponent.ConditionalCreate, issues, $"Rest.Resource['{systemComponent.Type}'].ConditionalCreate"),
                        ConditionalUpdate = systemComponent.ConditionalUpdate.IntersectBool(configuredComponent.ConditionalUpdate, issues, $"Rest.Resource['{systemComponent.Type}'].ConditionalUpdate"),

                        // List intersections
                        SearchInclude    = system.SupportsInclude ? systemComponent.SearchInclude.IntersectList(configuredComponent.SearchInclude, x => x, issues, $"Rest.Resource['{systemComponent.Type}'].SearchInclude").ToList() : Enumerable.Empty <string>(),
                        SearchRevInclude = systemComponent.SearchRevInclude.IntersectList(configuredComponent.SearchRevInclude, x => x, issues, $"Rest.Resource['{systemComponent.Type}'].SearchRevInclude").ToList(),
                        Interaction      = systemComponent.Interaction.IntersectList(configuredComponent.Interaction, x => x.Code, issues, $"Rest.Resource['{systemComponent.Type}'].Interaction"),
                        ReferencePolicy  = systemComponent.ReferencePolicy.IntersectList(configuredComponent.ReferencePolicy, x => x, issues, $"Rest.Resource['{systemComponent.Type}'].ReferencePolicy"),
                        SearchParam      = systemComponent.SearchParam.IntersectList(configuredComponent.SearchParam, x => string.Concat(x.Name, x.Type), issues, $"Rest.Resource['{systemComponent.Type}'].SearchParam"),

                        // Listed Enumerations intersections
                        Versioning        = systemComponent.Versioning.IntersectEnum(configuredComponent.Versioning, issues, $"Rest.Resource['{systemComponent.Type}'].Versioning"),
                        ConditionalRead   = systemComponent.ConditionalRead.IntersectEnum(configuredComponent.ConditionalRead, issues, $"Rest.Resource['{systemComponent.Type}'].ConditionalRead"),
                        ConditionalDelete = systemComponent.ConditionalDelete.IntersectEnum(configuredComponent.ConditionalDelete, issues, $"Rest.Resource['{systemComponent.Type}'].ConditionalDelete"),
                    };

                    rest.Resource.Add(interaction);
                }

                rest.Resource = rest.Resource.OrderBy(x => x.Type.ToString()).ToList();
            }

            if (strictConfig && issues.Any())
            {
                throw new UnsupportedConfigurationException(Core.Resources.UnsupportedConfigurationMessage, issues.Select(i => new OperationOutcomeIssue(OperationOutcomeConstants.IssueSeverity.Error, OperationOutcomeConstants.IssueType.Exception, i)).ToArray());
            }

            return(intersecting);
        }
Beispiel #11
0
        public static CapabilityStatement GenerateCapabilityStatement(string url)
        {
            var cs = new CapabilityStatement
            {
                Name         = "Azure HLS Team API Application FHIR Server",
                Status       = PublicationStatus.Draft,
                Experimental = true,
                Publisher    = "Microsoft Corporation",
                FhirVersion  = "R4.Core  0.95.0.0",
                Format       = new[] { "json", "xml" },
                Contact      = new List <ContactDetail>()
            };

            // cs.AcceptUnknown = CapabilityStatement.UnknownContentCode.Both;
            var cc = new ContactDetail
            {
                Name    = "Steve Ordahl",
                Telecom = new List <ContactPoint>
                {
                    new ContactPoint(ContactPoint.ContactPointSystem.Email, ContactPoint.ContactPointUse.Work,
                                     "*****@*****.**")
                }
            };

            cs.Contact.Add(cc);
            cs.Kind        = CapabilityStatement.CapabilityStatementKind.Instance;
            cs.Date        = "2018-05-06";
            cs.Description =
                new Markdown("This is the FHIR capability statement for the HLS Team API Application FHIR Server 3.0.1");
            cs.Software =
                new CapabilityStatement.SoftwareComponent
            {
                Name        = "Experimental Microsoft HLS Team FHIR Server API App",
                Version     = "0.9.1",
                ReleaseDate = "2018-05-06"
            };
            cs.Implementation = new CapabilityStatement.ImplementationComponent {
                Description = "MSHLS Experimental FHIR Server"
            };
            var endpos = url.ToLower().LastIndexOf("/metadata", StringComparison.Ordinal);

            if (endpos > -1)
            {
                url = url.Substring(0, endpos);
            }
            cs.Implementation.Url = url;

            var rc = new CapabilityStatement.RestComponent
            {
                Mode     = CapabilityStatement.RestfulCapabilityMode.Server,
                Security = new CapabilityStatement.SecurityComponent
                {
                    Service = new List <CodeableConcept>
                    {
                        new CodeableConcept("http://hl7.org/fhir/restful-security-service", "SMART-on-FHIR",
                                            "OAuth2 using SMART-on-FHIR profile (see http://docs.smarthealthit.org)")
                    },
                    Extension = new List <Extension>()
                }
            };

            //security profile
            var oauthex = new Extension
            {
                Extension = new List <Extension>(),
                Url       = "http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris"
            };

            oauthex.Extension.Add(new Extension("token",
                                                new FhirUri("https://login.microsoftonline.com/microsoft.onmicrosoft.com/oauth2/token")));
            oauthex.Extension.Add(new Extension("authorize",
                                                new FhirUri("https://login.microsoftonline.com/microsoft.onmicrosoft.com/oauth2/authorize")));
            rc.Security.Extension.Add(oauthex);
            rc.Security.Cors = true;
            //All controller resources
            var supported = Enum.GetValues(typeof(ResourceType));

            foreach (ResourceType k in supported)
            {
                var rescomp = new CapabilityStatement.ResourceComponent
                {
                    Type        = k,
                    Versioning  = CapabilityStatement.ResourceVersionPolicy.Versioned,
                    Interaction = new List <CapabilityStatement.ResourceInteractionComponent>
                    {
                        new CapabilityStatement.ResourceInteractionComponent {
                            Code = CapabilityStatement.TypeRestfulInteraction.Create
                        },
                        new CapabilityStatement.ResourceInteractionComponent {
                            Code = CapabilityStatement.TypeRestfulInteraction.Update
                        },
                        new CapabilityStatement.ResourceInteractionComponent {
                            Code = CapabilityStatement.TypeRestfulInteraction.Delete
                        },
                        new CapabilityStatement.ResourceInteractionComponent {
                            Code = CapabilityStatement.TypeRestfulInteraction.Read
                        },
                        new CapabilityStatement.ResourceInteractionComponent {
                            Code = CapabilityStatement.TypeRestfulInteraction.Vread
                        }
                    }
                };
                rc.Resource.Add(rescomp);
            }

            cs.Rest.Add(rc);
            return(cs);
        }
Beispiel #12
0
        public static Resource GetStatement(NameValueCollection queryParam)
        {
            string modeVal = Utilities.GetQueryValue("mode", queryParam);

            if (modeVal.ToLower() == "terminology")
            {
                return(TerminologyCapability.GetStatement(false));
            }

            CapabilityStatement capabilityStatement = new CapabilityStatement
            {
                Url         = TERMINZ_CANONICAL,
                Id          = "capability-fhir-server-patients-first",
                Description = new Markdown(TERMINZ_DESCRIPTION),
                Name        = "Patients First Terminology Server (Terminz)",
                Publisher   = "Patients First Ltd",
                Date        = "2019-05-08",
                Version     = "4.0.0",
                FhirVersion = FHIRVersion.N4_0_0,
                //Language = "en-NZ",  // review with next version of library - this needs to be a coded element!
                Status = PublicationStatus.Draft,
                //capabilityStatement.AcceptUnknown = CapabilityStatement.UnknownContentCode.Both;
                Experimental = true,
                Format       = new string[] { "json", "xml" },
                Software     = new CapabilityStatement.SoftwareComponent {
                    Name = "Health Intelligence Platform", Version = "6.9.6.0", ReleaseDate = "2019-05-08"
                },
                Kind           = CapabilityStatementKind.Instance,
                Implementation = new CapabilityStatement.ImplementationComponent {
                    Description = TERMINZ_DESCRIPTION, Url = TERMINZ_CANONICAL
                }
            };

            ContactDetail cd = new ContactDetail {
                Name = "Peter Jordan"
            };
            ContactPoint cp = new ContactPoint {
                System = ContactPoint.ContactPointSystem.Email, Value = "*****@*****.**"
            };

            cd.Telecom.Add(cp);
            capabilityStatement.Contact.Add(cd);

            // Add Extensions for supported Code Systems
            capabilityStatement.AddExtension(HL7_FHIR_CANONICAL + "/StructureDefinition/capabilitystatement-supported-system", new FhirUri("http://snomed.info/sct"));
            capabilityStatement.AddExtension(HL7_FHIR_CANONICAL + "/StructureDefinition/capabilitystatement-supported-system", new FhirUri("http://loinc.org"));
            capabilityStatement.AddExtension(HL7_FHIR_CANONICAL + "/StructureDefinition/capabilitystatement-supported-system", new FhirUri("http://nzmt.org.nz"));

            // create server object

            var server = new CapabilityStatement.RestComponent
            {
                Mode          = CapabilityStatement.RestfulCapabilityMode.Server,
                Documentation = new Markdown("RESTful Terminology Server")
            };

            server.Interaction.Add(new CapabilityStatement.SystemInteractionComponent
            {
                Code          = CapabilityStatement.SystemRestfulInteraction.Batch,
                Documentation = new Markdown("Supported for validate-code and translate operations.")
            });

            // Add CORS security
            server.Security = new CapabilityStatement.SecurityComponent {
                Cors = true
            };

            // create resource objects and add them to server object....

            // Capability Statement - only if /CapabilityStatement is supported where multiple CS exist

            // TerminologyCapabilities

            var resourceTerminologyCapabilities = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.TerminologyCapabilities,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confReadcs = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definition of the Terminology Capability Statement")
            };

            resourceTerminologyCapabilities.Interaction.Add(confReadcs);

            // Operation Definition

            var resourceOperationDefinition = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.OperationDefinition,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confReadOd = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definition of the Operation Definition")
            };

            resourceOperationDefinition.Interaction.Add(confReadOd);

            var confSearchOd = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Operation Definitions on the server")
            };

            resourceOperationDefinition.Interaction.Add(confSearchOd);

            // add search parameters

            var spOd0 = new CapabilityStatement.SearchParamComponent {
                Name = "identifier", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/OperationDefinition-identifier"
            };

            resourceOperationDefinition.SearchParam.Add(spOd0);

            var spOd1 = new CapabilityStatement.SearchParamComponent {
                Name = "url", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/OperationDefinition-url"
            };

            resourceOperationDefinition.SearchParam.Add(spOd1);

            // CodeSystem

            var resourceCodeSystem = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.CodeSystem,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confRead0 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definitions of Code Systems")
            };

            resourceCodeSystem.Interaction.Add(confRead0);

            var confSearch0 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Code Systems on the server")
            };

            resourceCodeSystem.Interaction.Add(confSearch0);

            // add search parameters
            var sp1 = new CapabilityStatement.SearchParamComponent {
                Name = "code", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-code"
            };

            resourceCodeSystem.SearchParam.Add(sp1);

            var sp2 = new CapabilityStatement.SearchParamComponent {
                Name = "date", Type = SearchParamType.Date, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-date"
            };
            //resourceCodeSystem.SearchParam.Add(sp2);

            var sp3 = new CapabilityStatement.SearchParamComponent {
                Name = "name", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-name"
            };
            //resourceCodeSystem.SearchParam.Add(sp3);

            var sp4 = new CapabilityStatement.SearchParamComponent {
                Name = "reference", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-reference"
            };
            //resourceCodeSystem.SearchParam.Add(sp4);

            var sp5 = new CapabilityStatement.SearchParamComponent {
                Name = "status", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-status"
            };
            //resourceCodeSystem.SearchParam.Add(sp5);

            var sp6 = new CapabilityStatement.SearchParamComponent {
                Name = "system", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-system"
            };

            resourceCodeSystem.SearchParam.Add(sp6);

            var sp7 = new CapabilityStatement.SearchParamComponent {
                Name = "url", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-url"
            };

            resourceCodeSystem.SearchParam.Add(sp7);

            var sp8 = new CapabilityStatement.SearchParamComponent {
                Name = "version", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-version"
            };

            resourceCodeSystem.SearchParam.Add(sp8);

            var sp9 = new CapabilityStatement.SearchParamComponent {
                Name = "identifier", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-identifier"
            };

            resourceCodeSystem.SearchParam.Add(sp9);

            var sp1a = new CapabilityStatement.SearchParamComponent {
                Name = "content-mode", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-content-mode"
            };

            resourceCodeSystem.SearchParam.Add(sp1a);

            var sp1b = new CapabilityStatement.SearchParamComponent {
                Name = "supplements", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/CodeSystem-supplements"
            };

            resourceCodeSystem.SearchParam.Add(sp1b);

            // ValueSet

            var resourceValueSet = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.ValueSet,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confRead = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definitions of Value Sets")
            };

            resourceValueSet.Interaction.Add(confRead);

            var confSearch = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Value Sets on the server")
            };

            resourceValueSet.Interaction.Add(confSearch);

            // add search parameters
            var sp11 = new CapabilityStatement.SearchParamComponent
            {
                Name = "code", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-code"
            };

            resourceValueSet.SearchParam.Add(sp11);

            var sp12 = new CapabilityStatement.SearchParamComponent
            {
                Name = "date", Type = SearchParamType.Date, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-date"
            };
            //resourceValueSet.SearchParam.Add(sp12);

            var sp13 = new CapabilityStatement.SearchParamComponent
            {
                Name = "name", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-name"
            };
            //resourceValueSet.SearchParam.Add(sp13);

            var sp14 = new CapabilityStatement.SearchParamComponent
            {
                Name = "reference", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-reference"
            };
            //resourceValueSet.SearchParam.Add(sp14);

            var sp15 = new CapabilityStatement.SearchParamComponent
            {
                Name = "status", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-status"
            };
            //resourceValueSet.SearchParam.Add(sp15);

            var sp16 = new CapabilityStatement.SearchParamComponent
            {
                Name = "system", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-system"
            };

            resourceValueSet.SearchParam.Add(sp16);

            var sp17 = new CapabilityStatement.SearchParamComponent
            {
                Name = "url", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-url"
            };

            resourceValueSet.SearchParam.Add(sp17);

            var sp18 = new CapabilityStatement.SearchParamComponent
            {
                Name = "version", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-version"
            };

            resourceValueSet.SearchParam.Add(sp18);

            var sp19 = new CapabilityStatement.SearchParamComponent
            {
                Name = "identifier", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ValueSet-identifier"
            };

            resourceValueSet.SearchParam.Add(sp19);

            // ConceptMap

            var resourceConceptMap = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.ConceptMap,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confRead2 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definitions of Concept Maps")
            };

            resourceConceptMap.Interaction.Add(confRead2);

            var confSearch2 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Concept Maps on the server")
            };

            resourceConceptMap.Interaction.Add(confSearch2);

            // add search parameters

            var sp21 = new CapabilityStatement.SearchParamComponent
            {
                Name = "date", Type = SearchParamType.Date, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-date"
            };
            //resourceConceptMap.SearchParam.Add(sp21);

            var sp22 = new CapabilityStatement.SearchParamComponent
            {
                Name = "name", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-name"
            };
            //resourceConceptMap.SearchParam.Add(sp22);

            var sp23 = new CapabilityStatement.SearchParamComponent
            {
                Name = "status", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-status"
            };
            //resourceConceptMap.SearchParam.Add(sp23);

            var sp24 = new CapabilityStatement.SearchParamComponent
            {
                Name = "source", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-source"
            };

            resourceConceptMap.SearchParam.Add(sp24);

            var sp25 = new CapabilityStatement.SearchParamComponent
            {
                Name = "target", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-target"
            };

            resourceConceptMap.SearchParam.Add(sp25);

            var sp26 = new CapabilityStatement.SearchParamComponent
            {
                Name = "url", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-url"
            };

            resourceConceptMap.SearchParam.Add(sp26);

            var sp27 = new CapabilityStatement.SearchParamComponent
            {
                Name = "version", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-version"
            };

            resourceConceptMap.SearchParam.Add(sp27);

            var sp28 = new CapabilityStatement.SearchParamComponent
            {
                Name = "identifier", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/ConceptMap-identifier"
            };

            resourceConceptMap.SearchParam.Add(sp28);

            // Naming System

            var resourceNamingSystem = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.NamingSystem,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            var confReadNs = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.Read,
                Documentation = new Markdown("Read allows clients to get the logical definitions of Naming Systems")
            };

            resourceNamingSystem.Interaction.Add(confReadNs);

            var confSearchNs = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Naming Systems on the server")
            };

            resourceNamingSystem.Interaction.Add(confSearchNs);

            // add search parameters

            var spNs = new CapabilityStatement.SearchParamComponent
            {
                Name = "identifier", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/NamingSystem-identifier"
            };

            resourceNamingSystem.SearchParam.Add(spNs);

            var spNs2 = new CapabilityStatement.SearchParamComponent
            {
                Name = "url", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/NamingSystem-url"
            };

            resourceNamingSystem.SearchParam.Add(spNs2);

            var spNs3 = new CapabilityStatement.SearchParamComponent
            {
                Name = "value", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/NamingSystem-value"
            };

            resourceNamingSystem.SearchParam.Add(spNs3);

            var spNs4 = new CapabilityStatement.SearchParamComponent
            {
                Name = "kind", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/NamingSystem-kind"
            };

            resourceNamingSystem.SearchParam.Add(spNs4);

            // Location

            var resourceLocation = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.Location,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            //var confRead3 = new CapabilityStatement.ResourceInteractionComponent();
            //confRead3.Code = CapabilityStatement.TypeRestfulInteraction.Read;
            //confRead3.Documentation = "Read allows clients to get the logical definitions of the locations";
            //resourceLocation.Interaction.Add(confRead3);

            var confSearch3 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Locations (NZ Healthcare Facilities) on the server")
            };

            resourceLocation.Interaction.Add(confSearch3);

            // add search parameters

            var sp31 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address", Type = SearchParamType.Date, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-address"
            };

            resourceLocation.SearchParam.Add(sp31);

            var sp32 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address-city", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-address-city"
            };

            resourceLocation.SearchParam.Add(sp32);

            var sp33 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address-postalcode", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-address-postalcode"
            };

            resourceLocation.SearchParam.Add(sp33);

            var sp34 = new CapabilityStatement.SearchParamComponent
            {
                Name = "identifier", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-identifier"
            };

            resourceLocation.SearchParam.Add(sp34);

            var sp35 = new CapabilityStatement.SearchParamComponent
            {
                Name = "name", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-name"
            };

            resourceLocation.SearchParam.Add(sp35);

            var sp36 = new CapabilityStatement.SearchParamComponent
            {
                Name = "type", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Location-type"
            };

            resourceLocation.SearchParam.Add(sp36);

            // Organization

            var resourceOrganization = new CapabilityStatement.ResourceComponent
            {
                Type         = ResourceType.Organization,
                ReadHistory  = false,
                UpdateCreate = false,
                Versioning   = CapabilityStatement.ResourceVersionPolicy.NoVersion
            };

            // add interactions
            //var confRead4 = new CapabilityStatement.ResourceInteractionComponent();
            //confRead4.Code = CapabilityStatement.TypeRestfulInteraction.Read;
            //confRead4.Documentation = "Read allows clients to get the logical definitions of the locations";
            //resourceOrganization.Interaction.Add(confRead4);

            var confSearch4 = new CapabilityStatement.ResourceInteractionComponent
            {
                Code          = CapabilityStatement.TypeRestfulInteraction.SearchType,
                Documentation = new Markdown("Search allows clients to find Organizations on the server")
            };

            resourceOrganization.Interaction.Add(confSearch4);

            // add search parameters

            var sp41 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address", Type = SearchParamType.Date, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-address"
            };

            resourceOrganization.SearchParam.Add(sp41);

            var sp42 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address-city", Type = SearchParamType.String, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-address-city"
            };

            resourceOrganization.SearchParam.Add(sp42);

            var sp43 = new CapabilityStatement.SearchParamComponent
            {
                Name = "address-postalcode", Type = SearchParamType.Token, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-address-postalcode"
            };

            resourceOrganization.SearchParam.Add(sp43);

            var sp44 = new CapabilityStatement.SearchParamComponent
            {
                Name = "identifier", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-identifier"
            };

            resourceOrganization.SearchParam.Add(sp44);

            var sp45 = new CapabilityStatement.SearchParamComponent
            {
                Name = "name", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-name"
            };

            resourceOrganization.SearchParam.Add(sp45);

            var sp46 = new CapabilityStatement.SearchParamComponent
            {
                Name = "type", Type = SearchParamType.Uri, Definition = HL7_FHIR_CANONICAL + "/SearchParameter/Organization-type"
            };

            resourceOrganization.SearchParam.Add(sp46);

            // add resources to server object

            //server.Resource.Add(resourceCapabilityStatement);

            server.Resource.Add(resourceTerminologyCapabilities);
            server.Resource.Add(resourceOperationDefinition);
            server.Resource.Add(resourceCodeSystem);
            server.Resource.Add(resourceValueSet);
            server.Resource.Add(resourceConceptMap);
            server.Resource.Add(resourceNamingSystem);
            server.Resource.Add(resourceLocation);
            server.Resource.Add(resourceOrganization);

            // add operations to server object

            var opCom1 = new CapabilityStatement.OperationComponent {
                Name = "lookup", Definition = TERMINZ_CANONICAL + "/OperationDefinition/CodeSystem-lookup"
            };

            server.Operation.Add(opCom1);

            var opCom1a = new CapabilityStatement.OperationComponent {
                Name = "validate-code", Definition = TERMINZ_CANONICAL + "/OperationDefinition/CodeSystem-validate-code"
            };

            //opCom5.FhirCommentsElement.Add(new FhirString("Supported in batch request"));
            server.Operation.Add(opCom1a);

            var opCom2 = new CapabilityStatement.OperationComponent {
                Name = "subsumes", Definition = TERMINZ_CANONICAL + "/OperationDefinition/CodeSystem-subsumes"
            };

            server.Operation.Add(opCom2);

            var opCom3 = new CapabilityStatement.OperationComponent {
                Name = "find-matches", Definition = HL7_FHIR_CANONICAL + "/OperationDefinition/CodeSystem-find-matches"
            };

            server.Operation.Add(opCom3);

            var opCom4 = new CapabilityStatement.OperationComponent {
                Name = "expand", Definition = TERMINZ_CANONICAL + "/OperationDefinition/ValueSet-expand"
            };

            server.Operation.Add(opCom4);

            var opCom5 = new CapabilityStatement.OperationComponent {
                Name = "validate-code", Definition = TERMINZ_CANONICAL + "/OperationDefinition/ValueSet-validate-code"
            };

            //opCom5.FhirCommentsElement.Add(new FhirString("Supported in batch request"));
            server.Operation.Add(opCom5);

            var opCom6 = new CapabilityStatement.OperationComponent {
                Name = "translate", Definition = TERMINZ_CANONICAL + "/OperationDefinition/ConceptMap-translate"
            };

            //opCom6.FhirCommentsElement.Add(new FhirString("Supported in batch request"));
            server.Operation.Add(opCom6);

            var opCom7 = new CapabilityStatement.OperationComponent {
                Name = "closure", Definition = HL7_FHIR_CANONICAL + "/OperationDefinition/ConceptMap-closure"
            };

            server.Operation.Add(opCom7);

            var opCom8 = new CapabilityStatement.OperationComponent {
                Name = "preferred-id", Definition = HL7_FHIR_CANONICAL + "/OperationDefinition/NamingSystem-preferred-id"
            };

            server.Operation.Add(opCom8);

            var opCom9 = new CapabilityStatement.OperationComponent {
                Name = "versions", Definition = HL7_FHIR_CANONICAL + "/OperationDefinition/CapabilityStatement-versions"
            };

            server.Operation.Add(opCom9);

            // add server to capability statement object
            capabilityStatement.Rest.Add(server);

            // create text
            AddNarrative(capabilityStatement, server);

            return(capabilityStatement);
        }
Beispiel #13
0
        public static CapabilityStatement GenerateCapabilityStatement()
        {
            CapabilityStatement cs = new CapabilityStatement();

            cs.Name   = "Azure HLS Team API Application FHIR Server";
            cs.Status = PublicationStatus.Draft;

            cs.Experimental  = true;
            cs.Publisher     = "Microsoft Corporation";
            cs.FhirVersion   = "3.0.0";
            cs.AcceptUnknown = CapabilityStatement.UnknownContentCode.Both;
            cs.Format        = new string[] { "json", "xml" };
            cs.Contact       = new List <ContactDetail>();
            ContactDetail cc = new ContactDetail();

            cc.Name    = "Steve Ordahl";
            cc.Telecom = new List <ContactPoint>();
            cc.Telecom.Add(new ContactPoint(ContactPoint.ContactPointSystem.Email, ContactPoint.ContactPointUse.Work, "*****@*****.**"));
            cs.Contact.Add(cc);

            CapabilityStatement.RestComponent rc = new CapabilityStatement.RestComponent();

            rc.Mode = CapabilityStatement.RestfulCapabilityMode.Server;
            //security profile
            rc.Security         = new CapabilityStatement.SecurityComponent();
            rc.Security.Service = new List <CodeableConcept>();
            rc.Security.Service.Add(new CodeableConcept("http://hl7.org/fhir/restful-security-service", "SMART-on-FHIR", "OAuth2 using SMART-on-FHIR profile (see http://docs.smarthealthit.org)"));
            rc.Security.Extension = new List <Extension>();
            Extension oauthex = new Extension();

            oauthex.Extension = new List <Extension>();
            oauthex.Url       = "http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris";
            oauthex.Extension.Add(new Extension("token", new FhirUri("https://login.microsoftonline.com/microsoft.onmicrosoft.com/oauth2/token")));
            oauthex.Extension.Add(new Extension("authorize", new FhirUri("https://login.microsoftonline.com/microsoft.onmicrosoft.com/oauth2/authorize")));
            rc.Security.Extension.Add(oauthex);
            rc.Security.Cors = true;
            //All controller resources
            var supported = System.Enum.GetValues(typeof(ResourceType));

            foreach (ResourceType k in supported)
            {
                CapabilityStatement.ResourceComponent rescomp = new CapabilityStatement.ResourceComponent();
                rescomp.Type        = k;
                rescomp.Versioning  = CapabilityStatement.ResourceVersionPolicy.Versioned;
                rescomp.Interaction = new List <CapabilityStatement.ResourceInteractionComponent>();
                rescomp.Interaction.Add(new CapabilityStatement.ResourceInteractionComponent()
                {
                    Code = CapabilityStatement.TypeRestfulInteraction.Create
                });
                rescomp.Interaction.Add(new CapabilityStatement.ResourceInteractionComponent()
                {
                    Code = CapabilityStatement.TypeRestfulInteraction.Update
                });
                rescomp.Interaction.Add(new CapabilityStatement.ResourceInteractionComponent()
                {
                    Code = CapabilityStatement.TypeRestfulInteraction.Delete
                });
                rescomp.Interaction.Add(new CapabilityStatement.ResourceInteractionComponent()
                {
                    Code = CapabilityStatement.TypeRestfulInteraction.Read
                });
                rescomp.Interaction.Add(new CapabilityStatement.ResourceInteractionComponent()
                {
                    Code = CapabilityStatement.TypeRestfulInteraction.Vread
                });
                rc.Resource.Add(rescomp);
            }
            cs.Rest.Add(rc);
            return(cs);
        }
        public static CapabilityStatement.ResourceComponent AddCoreSearchParamsResource(CapabilityStatement.ResourceComponent r,
                                                                                        IEnumerable <ModelInfo.SearchParamDefinition> availableModelInfo)
        {
            if (availableModelInfo != null)
            {
                var parameters =
                    availableModelInfo.Where(sp => sp.Resource == r.Type.GetLiteral())
                    .Select(sp => new CapabilityStatement.SearchParamComponent
                {
                    Name          = sp.Name,
                    Type          = sp.Type,
                    Documentation = sp.Description
                });

                r.SearchParam.AddRange(parameters);
            }
            return(r);
        }