HL7 FHIR-Routing mit erweiterten Such-und Modifikatoren in. Net

Question

Ich versuche derzeit, mich um das Routing mit FHIR-Suche einzuwickeln.

Im Abschnitt 2.1.1.48 String in der Webseite https://www.hl7.org/fhir/search.html gibt es einen Abschnitt darüber, wie Sie Modifikatoren verwenden können, um Ergebnisse zurückzugeben, die den angegebenen Parameterwert enthalten oder damit übereinstimmen.

Ex: "Name: genaue/enthält"

[base]/Patient?name=eve 
[base]/Patient?name:contains=eve  
[base]/Patient?name:exact=Eve 

Ich habe noch nie solche URLs mit diesen kundenspezifischen Modifikatoren gesehen in zb akzeptiert Ein Web-API-Service aus der Box.

Soweit ich sehen kann, ist es nicht etwas in den Zeilen der

[Route("{type}/name:contains/{name}")] 
public HttpResponseMessage GetContainsName(string name){ 

//do something 
} 

[Route("{type}/name:exact/{name}")] 
public HttpResponseMessage GetExactName(string name) { 
//do something else 
} 

Answer 1

Im sqlonfhir Server schreiben erlaubt (und ich glaube, auch den Spark-Server) die Verarbeitung der Parameter nicht getan durch Webapi-Routing.

Wir beide verwenden das Routing zum Extrahieren des Ressourcennamens, der ID, der Operation (und des Verlaufs und der Versions-ID). Alle anderen Funktionen werden manuell ausgeführt, indem der Inhalt aus RequestUrl extrahiert und verarbeitet wird.

[HttpGet, Route("{ResourceName}/{id}/_history/{vid}")] 
public HttpResponseMessage Get(string ResourceName, string id, string vid) 
{ 
    var buri = this.CalculateBaseURI("{ResourceName}"); 
    fhirstore.RegisterKnownUrl(buri); 

    if (!Id.IsValidValue(id)) 
    { 
     throw new FhirServerException(HttpStatusCode.BadRequest, "ID [" + id + "] is not a valid FHIR Resource ID"); 
    } 

    IModelBase model = GetModel(ResourceName, GetInputs(buri)); 
    var resource = model.Get(id, vid, summary); 
    if (resource != null) 
    { 
     var msg = Request.ResourceResponse(resource, HttpStatusCode.OK); 
     msg.Headers.Location = resource.ResourceIdentity().WithBase(resource.ResourceBase); 
     msg.Headers.Add("ETag", String.Format("\"{0}\"", resource.Meta.VersionId)); 
     return msg; 
    } 

    // this request is a "you wanted what?" 
    return Request.CreateResponse(HttpStatusCode.NotFound); 
} 

(keine vollständiger Code-Extrakt - ich habe den Code gestrippt, die binären Ressourcen behandelt, und die _summary Parameter Content-Verarbeitung)

Einen weiteren Punkt von diesem Code, der erwähnenswert ist, dass die Verarbeitung ist innerhalb des Modells getan (so kann ich Unit-Test extern auf den Web-Kontext testen). Und die CalculateBaseURI-Methode stellt sicher, dass die URL der Anfrage auf den Speicherort des Ergebnisses angewendet wird, ohne dass eine Konfigurationseinstellung erforderlich ist, die dem Server mitteilt, was er dort ablegen soll.

Und während ich darüber diskutiere, verwenden wir Medien-Formatierer, um den Ressourcen-Inhalt zu analysieren.

Answer 2

Dies ist eine mögliche Lösung, um einen FHIR-Server in Betrieb zu nehmen. Ich habe etwas Code von der Sparks.Engine verwendet, so dass es einfacher ist, die Modifizierer zu erhalten und die URL zu "dekodieren".

Sie werden hoffentlich Treffer in eine der beiden Methoden erhalten

Die Methoden Urls wie diese für den Server

fhir/Patient/1 
fhir/Patient?name=something 
fhir/?_query="nameOfQuery"&name:contains="someName" 

Der Code akzeptieren sollte sich wie diese

namespace FHIRServer.Controllers 
{ 
    [RoutePrefix("fhir"), EnableCors("*", "*", "*", "*")] 
    [RouteDataValuesOnly] 
    public class FhirController : ApiController 
    { 
     public FhirController() 
     { 
     } 

     [HttpGet, Route("{type}")] 
     public HttpResponseMessage ResourceQuery(string type) 
     { 
      var searchParams = Request.GetSearchParams(); 

      // do something with the search params 
     } 

     [HttpGet, Route("")] 
     public HttpResponseMessage Query(string _query) 
     { 
      var searchParams = Request.GetSearchParams(); 

      // do something with the search params 
     } 
    } 
} 

Das sieht Request.GetSearchParams() ist ein Teil von Sparks.Engine, die Sie hier finden können. Ich habe SparksEngine zu unserer FH hinzugefügt IR-Lösung, da es bereits viele Funktionen implementiert hat.

Die

var searchParams = Request.GetSearchParams(); 

die verschiedenen Parameter in der URL-Analyse hilft und macht es viel einfacher, nach vorn von dort aus zu gehen.

Diese Antwort wurde von der vorherigen Antwort in diesem Thread von Brian inspiriert.