Ricerca delle risorse FHIR

Questa pagina spiega le istruzioni di base per la ricerca di risorse FHIR in un archivio FHIR. La ricerca di risorse FHIR è il modo principale per eseguire query e ottenere approfondimenti dai dati FHIR.

Puoi cercare risorse FHIR nell'API Cloud Healthcare nei seguenti modi:

Questa pagina riepiloga molte delle funzionalità di ricerca utilizzate di frequente, ma non è un elenco esaustivo delle parti della specifica di ricerca FHIR supportate dall'API Cloud Healthcare.

Utilizzo del visualizzatore FHIR

Il visualizzatore FHIR è una pagina della console Google Cloud che ti consente di cercare e visualizzare i contenuti delle risorse FHIR.

Per cercare risorse in un archivio FHIR, completa i seguenti passaggi:

  1. Nella console Google Cloud , vai alla pagina Visualizzatore FHIR.

    Vai al visualizzatore FHIR

  2. Nell'elenco a discesa Archivio FHIR, seleziona un set di dati, quindi seleziona un archivio FHIR nel set di dati.

  3. Per filtrare l'elenco dei tipi di risorse, cerca quelli che vuoi visualizzare:

    1. Fai clic sul campo Tipo di risorsa.

    2. Nell'elenco a discesa Proprietà che viene visualizzato, seleziona Tipo di risorsa.

    3. Inserisci un tipo di risorsa.

    4. Per cercare un altro tipo di risorsa, seleziona OR dall'elenco a discesa Operatori visualizzato, quindi inserisci un altro tipo di risorsa.

  4. Nell'elenco dei tipi di risorse, seleziona quello su cui vuoi eseguire la ricerca.

  5. Nella casella di ricerca della tabella delle risorse visualizzata, inserisci il valore che vuoi cercare.

Il visualizzatore FHIR mostra i risultati di ricerca in una tabella. Dopo aver selezionato una risorsa, il visualizzatore FHIR mostra i contenuti della risorsa.

Quando visualizzi i contenuti di una risorsa, puoi cercare i dati al suo interno.

Per cercare dati all'interno di una risorsa:

  1. Seleziona una risorsa.

  2. Nel riquadro Visualizzatore FHIR, fai clic sulla scheda Elementi.

  3. Nella casella di ricerca, inserisci il valore che vuoi cercare.

Download di dati binari all'interno delle risorse FHIR

Per scaricare i dati binari disponibili associati a una risorsa nel visualizzatore FHIR:

  1. Seleziona una risorsa.

  2. Nel riquadro Visualizzatore FHIR, fai clic sulla scheda Elementi.

  3. Se necessario, espandi gli elementi per accedere all'elemento risorsa richiesto.

  4. Fai clic su Scarica file per scaricare i dati disponibili.

Creare ed eseguire query di ricerca avanzate

Puoi utilizzare query di ricerca avanzata per cercare risorse FHIR specifiche utilizzando la specifica di ricerca FHIR.

Per creare una query di ricerca avanzata, completa i seguenti passaggi:

  1. Nella pagina Visualizzatore FHIR, fai clic sulla scheda Cerca.

  2. Per creare una query di ricerca, fai clic su Apri Query Builder.

    Viene visualizzato il riquadro Selezione query.

  3. Dall'elenco Seleziona un tipo di risorsa FHIR, scegli il tipo di risorsa FHIR che vuoi cercare.

  4. Fai clic su Continua.

  5. Dall'elenco Parametro, seleziona il parametro che vuoi utilizzare per cercare le risorse.

  6. Nell'elenco Modificatore, seleziona il modificatore da applicare alla query. L'elenco include solo i modificatori compatibili con il tipo di dati del parametro selezionato.

    Questa è una selezione facoltativa. Se non viene selezionato alcun modificatore, viene eseguito un controllo di uguaglianza.

  7. Nel campo Valore, inserisci il valore del parametro di ricerca.

  8. Per aggiungere più di un valore parametro, fai clic su OR. In questo modo puoi includere più valori del parametro della risorsa nella query di ricerca.

    Mentre crei la query di ricerca, questa viene visualizzata nel riquadro Anteprima query. Per visualizzare l'URL completo della query di ricerca, fai clic su Mostra percorso completo.

  9. Per aggiungere più di un parametro, fai clic su E.

  10. Fai clic su Continua.

  11. Per includere le risorse a cui fanno riferimento quelle restituite nella query di ricerca, scegli il parametro della risorsa dall'elenco a discesa Parametri inclusi.

  12. Per includere le risorse che fanno riferimento a quelle restituite nella query di ricerca, scegli il parametro della risorsa dall'elenco a discesa Inverti parametri inclusi.

  13. Fai clic su Fine per salvare la query di ricerca.

    La query di ricerca salvata viene visualizzata nel campo Operazione di ricerca FHIR.

  14. Per cercare le risorse con la query, fai clic su Esegui ricerca.

    I risultati di ricerca vengono visualizzati nell'elenco Risultati di ricerca. Per visualizzare i dettagli di una risorsa restituita dalla ricerca, fai clic su una risorsa nell'elenco.

  15. Per salvare la query come modello di query, fai clic su Salva modello e scegli Salva modello o Salva modello con nome. Ti viene chiesto un nome e una descrizione per la query. I parametri di ricerca vengono salvati in un modello, ma tutti i valori definiti vengono rimossi.

Query di ricerca di esempio

L'esempio seguente mostra una query di ricerca che cerca le risorse Claim di un operatore sanitario specifico, Practitioner/12345, per il mese di agosto 2021:

  • Parametro: care-team
    • Valore: Practitioner/12345
  • Operatore: AND
  • Parametro: created
    • Prefisso: lt (lesser than)
    • Valore: 8/1/21, 12:00 AM
  • Operatore: AND
  • Parametro: created
    • Prefisso: gt (greater than)
    • Valore: 8/31/21, 11:59 PM

Questa operazione viene configurata come segue nel riquadro Selezione query e l'anteprima della query viene visualizzata nel riquadro Anteprima query. La query verrà visualizzata nel campo Operazione di ricerca FHIR.

Query di ricerca avanzata FHIR

Modificare le query di ricerca

Per modificare una query di ricerca, procedi in uno dei seguenti modi:

  • Per modificare la query in Query Builder, fai clic su Apri Query Builder.
  • Per modificare manualmente la query, modifica i valori dei parametri nella casella di testo.

Esecuzione di modelli di query

Per eseguire una query da un modello salvato:

  1. Fai clic su Modelli salvati.

    Viene visualizzata la scheda Modelli di ricerca del riquadro Selezione query, che mostra tutti i modelli di query salvati.

  2. Seleziona il modello di query che vuoi eseguire e fai clic su Fine.

    La query di ricerca del modello viene visualizzata nel campo Operazione di ricerca FHIR senza valori.

  3. Per definire i valori della query di ricerca, modifica i valori dei parametri nel campo.

  4. Fai clic su Esegui ricerca per cercare risorse con la query.

Condividere risorse FHIR

Puoi condividere un link alle versioni attuali o cronologiche di una risorsa FHIR.

Console

  1. Nella console Google Cloud , vai alla pagina Visualizzatore FHIR.

    Vai al visualizzatore FHIR

  2. Nel menu Archivio FHIR, seleziona un set di dati, quindi seleziona un archivio FHIR nel set di dati.

  3. Per filtrare l'elenco dei tipi di risorse FHIR, cerca i tipi di risorse che vuoi visualizzare.

  4. Fai clic sul campo Tipo di risorsa.

  5. Nell'elenco a discesa Proprietà che viene visualizzato, seleziona Tipo di risorsa.

  6. Inserisci un tipo di risorsa FHIR.

  7. Nell'elenco dei tipi di risorse FHIR, seleziona un tipo di risorsa.

  8. Nella tabella delle risorse FHIR visualizzata, seleziona o cerca una risorsa.

  9. Nel riquadro Visualizzatore FHIR, fai clic su Condividi. Un link per condividere la risorsa FHIR viene copiato automaticamente negli appunti.

Utilizzo del metodo search

Per cercare risorse FHIR con l'API REST, utilizza il metodo projects.locations.datasets.fhirStores.fhir.search. Puoi chiamare il metodo utilizzando le richieste GET o POST.

Utilizzo del metodo search con GET

Gli esempi riportati di seguito mostrano come cercare le risorse in un determinato archivio FHIR utilizzando il metodo projects.locations.datasets.fhirStores.fhir.search con GET.

curl

Per cercare le risorse in un archivio FHIR, effettua una richiesta GET e specifica le seguenti informazioni:

  • Il nome del set di dati
  • Il nome del datastore FHIR
  • Il tipo di risorsa da cercare
  • Una stringa di query contenente le informazioni che stai cercando, come descritto nella sezione Creazione di una query di ricerca
  • Un token di accesso

Il seguente esempio mostra una richiesta GET mediante curl per cercare tutti i pazienti con il cognome "Smith".

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient?family:exact=Smith"

Se la richiesta riesce, il server restituisce la risposta come FHIR Bundle in formato JSON. Bundle.type è searchset e i risultati di ricerca sono voci nell'array Bundle.entry. In questo esempio, la richiesta restituisce una singola risorsa Patient, inclusi i dati al suo interno:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

PowerShell

Per cercare le risorse in un archivio FHIR, effettua una richiesta GET e specifica le seguenti informazioni:

  • Il nome del set di dati
  • Il nome del datastore FHIR
  • Il tipo di risorsa da cercare
  • Una stringa di query contenente le informazioni che stai cercando, come descritto nella sezione Creazione di una query di ricerca
  • Un token di accesso

Il seguente esempio mostra una richiesta GET mediante Windows PowerShell per cercare tutti i pazienti con il cognome "Smith".

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-RestMethod `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/RESOURCE_TYPE?family:exact=Smith" | ConvertTo-Json

Se la richiesta riesce, il server restituisce la risposta come FHIR Bundle in formato JSON. Bundle.type è searchset e i risultati di ricerca sono voci nell'array Bundle.entry. In questo esempio, la richiesta restituisce una singola risorsa Patient, inclusi i dati al suo interno:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collections;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;

public class FhirResourceSearchGet {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  // The endpoint URL for the Healthcare API. Required for HttpClient.
  private static final String API_ENDPOINT = "https://healthcare.googleapis.com";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void fhirResourceSearchGet(String resourceName)
      throws IOException, URISyntaxException {
    // String resourceName =
    //    String.format(
    //        FHIR_NAME, "project-id", "region-id", "dataset-id", "fhir-store-id");
    // String resourceType = "Patient";

    // Instantiate the client, which will be used to interact with the service.
    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%s/v1/%s", API_ENDPOINT, resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    // To set additional parameters for search filtering, add them to the URIBuilder. For
    // example, to search for a Patient with the family name "Smith", specify the following:
    // uriBuilder.setParameter("family:exact", "Smith");

    HttpUriRequest request =
        RequestBuilder.get()
            .setUri(uriBuilder.build())
            .build();

    // Execute the request and process the results.
    HttpResponse response = httpClient.execute(request);
    HttpEntity responseEntity = response.getEntity();
    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
      System.err.print(
          String.format(
              "Exception searching GET FHIR resources: %s\n", response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource GET search results: ");
    responseEntity.writeTo(System.out);
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));
    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };
    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }

  private static String getAccessToken() throws IOException {
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    return credential.refreshAccessToken().getTokenValue();
  }
}

Node.js

// Import google-auth-library for authentication.
const {GoogleAuth} = require('google-auth-library');

const searchFhirResourcesGet = async () => {
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
  });
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const fhirStoreId = 'my-fhir-store';
  // const resourceType = 'Patient';
  const url = `https://healthcare.googleapis.com/v1/projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir/${resourceType}`;

  const params = {};
  // Specify search filters in a params object. For example, to filter on a
  // Patient with the last name "Smith", set resourceType to "Patient" and
  // specify the following params:
  // params = {'family:exact' : 'Smith'};
  const client = await auth.getClient();
  const response = await client.request({url, method: 'GET', params});
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesGet();

Python

def search_resources_get(
    project_id,
    location,
    dataset_id,
    fhir_store_id,
    resource_type,
):
    """
    Uses the searchResources GET method to search for resources in the given FHIR store.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/fhir
    before running the sample."""
    # Imports Python's built-in "os" module
    import os

    # Imports the google.auth.transport.requests transport
    from google.auth.transport import requests

    # Imports a module to allow authentication using a service account
    from google.oauth2 import service_account

    # Gets credentials from the environment.
    credentials = service_account.Credentials.from_service_account_file(
        os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
    )
    scoped_credentials = credentials.with_scopes(
        ["https://www.googleapis.com/auth/cloud-platform"]
    )
    # Creates a requests Session object with the credentials.
    session = requests.AuthorizedSession(scoped_credentials)

    # URL to the Cloud Healthcare API endpoint and version
    base_url = "https://healthcare.googleapis.com/v1"

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the parent dataset's ID
    # fhir_store_id = 'my-fhir-store' # replace with the FHIR store ID
    # resource_type = 'Patient'  # replace with the FHIR resource type
    url = f"{base_url}/projects/{project_id}/locations/{location}"

    resource_path = "{}/datasets/{}/fhirStores/{}/fhir/{}".format(
        url, dataset_id, fhir_store_id, resource_type
    )

    response = session.get(resource_path)
    response.raise_for_status()

    resources = response.json()

    print(
        "Using GET request, found a total of {} {} resources:".format(
            resources["total"], resource_type
        )
    )
    print(json.dumps(resources, indent=2))

    return resources

Utilizzo del metodo search con POST

Gli esempi riportati di seguito mostrano come cercare le risorse in un determinato archivio FHIR utilizzando il metodo projects.locations.datasets.fhirStores.fhir.search con POST.

curl

Per cercare le risorse in un archivio FHIR, effettua una richiesta POST e specifica le seguenti informazioni:

  • Il nome del set di dati
  • Il nome del datastore FHIR
  • Il tipo di risorsa da cercare
  • Una stringa di query contenente le informazioni che stai cercando, come descritto nella sezione Creazione di una query di ricerca
  • Un token di accesso

Il seguente esempio mostra una richiesta POST mediante curl per cercare tutti i pazienti con il cognome "Smith".

curl -X POST \
    --data "" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/fhir+json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/_search?family:exact=Smith"

Se la richiesta riesce, il server restituisce la risposta come FHIR Bundle in formato JSON. Bundle.type è searchset e i risultati di ricerca sono voci nell'array Bundle.entry. In questo esempio, la richiesta restituisce una singola risorsa Patient, inclusi i dati al suo interno:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

PowerShell

Per cercare le risorse in un archivio FHIR, effettua una richiesta POST e specifica le seguenti informazioni:

  • Il nome del set di dati
  • Il nome del datastore FHIR
  • Il tipo di risorsa da cercare
  • Una stringa di query contenente le informazioni che stai cercando, come descritto nella sezione Creazione di una query di ricerca
  • Un token di accesso

Il seguente esempio mostra una richiesta POST mediante Windows PowerShell per cercare tutti i pazienti con il cognome "Smith".

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-RestMethod `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/fhir+json; charset=utf-8" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/_search?family:exact=Smith" | ConvertTo-Json

Se la richiesta riesce, il server restituisce la risposta come FHIR Bundle in formato JSON. Bundle.type è searchset e i risultati di ricerca sono voci nell'array Bundle.entry. In questo esempio, la richiesta restituisce una singola risorsa Patient, inclusi i dati al suo interno:

{
  "entry": [
    {
      "fullUrl": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/PATIENT_ID",
      "resource": {
        "birthDate": "1970-01-01",
        "gender": "female",
        "id": "PATIENT_ID",
        "meta": {
          "lastUpdated": "LAST_UPDATED",
          "versionId": "VERSION_ID"
        },
        "name": [
          {
            "family": "Smith",
            "given": [
              "Darcy"
            ],
            "use": "official"
          }
        ],
        "resourceType": "Patient"
      },
      "search": {
        "mode": "match"
      }
    }
  ],
  "link": [
    {
      "url": "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/fhirStores/FHIR_STORE_ID/fhir/Patient/?family%3Aexact=Smith"
    }
  ],
  "resourceType": "Bundle",
  "total": 1,
  "type": "searchset"
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collections;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;

public class FhirResourceSearchPost {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  // The endpoint URL for the Healthcare API. Required for HttpClient.
  private static final String API_ENDPOINT = "https://healthcare.googleapis.com";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void fhirResourceSearchPost(String resourceName)
      throws IOException, URISyntaxException {
    // String resourceName =
    //    String.format(
    //        FHIR_NAME, "project-id", "region-id", "dataset-id", "store-id", "resource-type");

    // Instantiate the client, which will be used to interact with the service.
    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%s/v1/%s/_search", API_ENDPOINT, resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    // To set additional parameters for search filtering, add them to the URIBuilder. For
    // example, to search for a Patient with the family name "Smith", specify the following:
    // uriBuilder.setParameter("family:exact", "Smith");

    // Set a body otherwise HttpClient complains there is no Content-Length set.
    StringEntity requestEntity = new StringEntity("");

    HttpUriRequest request =
        RequestBuilder.post()
            .setUri(uriBuilder.build())
            .setEntity(requestEntity)
            .addHeader("Content-Type", "application/fhir+json")
            .addHeader("Accept-Charset", "utf-8")
            .addHeader("Accept", "application/fhir+json; charset=utf-8")
            .build();

    // Execute the request and process the results.
    HttpResponse response = httpClient.execute(request);
    HttpEntity responseEntity = response.getEntity();
    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
      System.err.print(
          String.format(
              "Exception searching POST FHIR resources: %s\n",
              response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource POST search results: ");
    responseEntity.writeTo(System.out);
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }

  private static String getAccessToken() throws IOException {
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    return credential.refreshAccessToken().getTokenValue();
  }
}

Node.js

// Import google-auth-library for authentication.
const {GoogleAuth} = require('google-auth-library');

const searchFhirResourcesPost = async () => {
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
    // Set application/fhir+json header because this is a POST request.
    headers: {'Content-Type': 'application/fhir+json'},
  });
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const fhirStoreId = 'my-fhir-store';
  // const resourceType = 'Patient';
  const url = `https://healthcare.googleapis.com/v1/projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir/${resourceType}/_search`;

  const params = {};
  // Specify search filters in a params object. For example, to filter on a
  // Patient with the last name "Smith", set resourceType to "Patient" and
  // specify the following params:
  // params = {'family:exact' : 'Smith'};
  const client = await auth.getClient();
  const response = await client.request({url, method: 'POST', params});
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesPost();

Python

def search_resources_post(project_id, location, dataset_id, fhir_store_id):
    """
    Searches for resources in the given FHIR store. Uses the
    _search POST method and a query string containing the
    information to search for. In this sample, the search criteria is
    'family:exact=Smith' on a Patient resource.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/fhir
    before running the sample."""
    # Imports Python's built-in "os" module
    import os

    # Imports the google.auth.transport.requests transport
    from google.auth.transport import requests

    # Imports a module to allow authentication using a service account
    from google.oauth2 import service_account

    # Gets credentials from the environment.
    credentials = service_account.Credentials.from_service_account_file(
        os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
    )
    scoped_credentials = credentials.with_scopes(
        ["https://www.googleapis.com/auth/cloud-platform"]
    )
    # Creates a requests Session object with the credentials.
    session = requests.AuthorizedSession(scoped_credentials)

    # URL to the Cloud Healthcare API endpoint and version
    base_url = "https://healthcare.googleapis.com/v1"

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the parent dataset's ID
    # fhir_store_id = 'my-fhir-store' # replace with the FHIR store ID
    url = f"{base_url}/projects/{project_id}/locations/{location}"

    fhir_store_path = "{}/datasets/{}/fhirStores/{}/fhir".format(
        url, dataset_id, fhir_store_id
    )

    resource_path = f"{fhir_store_path}/Patient/_search?family:exact=Smith"

    # Sets required application/fhir+json header on the request
    headers = {"Content-Type": "application/fhir+json;charset=utf-8"}

    response = session.post(resource_path, headers=headers)
    response.raise_for_status()

    resources = response.json()
    print(
        "Using POST request, found a total of {} Patient resources:".format(
            resources["total"]
        )
    )

    print(json.dumps(resources, indent=2))

    return resources

Creare una query di ricerca

La stringa di query è una serie di coppie name=value codificate nel formato URL. Una ricerca combina tutte le coppie con un AND logico. Ogni valore può essere un elenco di valori separati da virgole, che vengono trattati come un OR logico di questi valori. Ad esempio, Patient?key1=value1&key2=value2,value3 è una ricerca di Risorse per i pazienti utilizzando i seguenti criteri:

(key1 = value1) AND (key2 = value2 OR key2 = value3)

Non esiste una sintassi per eseguire un OR di due coppie name=value.

Ogni tipo di risorsa FHIR definisce i propri parametri di ricerca in ogni versione di FHIR. I parametri disponibili sono documentati nella specifica FHIR per ogni risorsa. Per un esempio, vedi FHIR R4 Patient. Puoi recuperare i parametri in modo programmatico tramite la dichiarazione di funzionalità. L'API Cloud Healthcare supporta la maggior parte dei parametri di ricerca; puoi trovare le esclusioni nella dichiarazione di funzionalità o nella dichiarazione di conformità FHIR.

Impaginazione e ordinamento

Il numero di risorse restituite in ogni pagina dei risultati di ricerca FHIR dipende dai seguenti fattori:

  • Il parametro _count. Controlla il numero massimo di risorse restituite dal metodo di ricerca. Ad esempio, _count=10 restituisce al massimo 10 risorse corrispondenti alla query. Il valore predefinito è 100 e il valore massimo consentito è 1000.
  • Le dimensioni dei dati di risposta. Una pagina di risultati di ricerca potrebbe restituire meno risorse rispetto al valore specificato nel parametro _count se le dimensioni della risposta sono elevate.

Se una ricerca restituisce più risorse del numero di risorse che rientrano in una pagina, la risposta include un URL di impaginazione nel campo Bundle.link. In questo campo potrebbero essere restituiti più valori; il valore con Bundle.link.relation = next indica che puoi utilizzare il Bundle.link.url corrispondente per recuperare la pagina successiva.

Il valore di Bundle.total indica il numero totale di risorse corrispondenti. Questo valore è esatto se i risultati rientrano interamente in una pagina, ma diventa una stima approssimativa man mano che il numero di risultati supera una pagina. Puoi ottenere un totale esatto per una ricerca che corrisponde a molti risultati seguendo ripetutamente i link di paginazione finché i risultati non sono esauriti.

Per saperne di più su impaginazione e totali di ricerca, vedi Implementare l'impaginazione e i totali di ricerca con la ricerca FHIR.

Puoi ordinare i risultati utilizzando il parametro _sort, che accetta un elenco separato da virgole di nomi di parametri di ricerca in ordine di priorità. Puoi utilizzare un prefisso - per indicare l'ordine decrescente. Ad esempio, la seguente query ordina in base allo stato in ordine crescente, risolve i pareggi in base alla data in ordine decrescente e risolve gli eventuali pareggi rimanenti in base alla categoria in ordine crescente:

_sort=status,-date,category

_sort è supportato solo per i parametri di ricerca di tipo number, data, string, token e quantity. Per ordinare utilizzando altri tipi di parametri di ricerca (ad esempio reference), utilizza le ricerche personalizzate FHIR per creare, ad esempio, un parametro di ricerca string nel campo reference.

Ritardo di indicizzazione

Le risorse FHIR vengono indicizzate in modo asincrono, pertanto potrebbe esserci un leggero ritardo tra il momento in cui una risorsa viene creata o modificata e il momento in cui la modifica si riflette nei risultati di ricerca. L'unica eccezione sono i dati dell'identificatore di risorsa, che vengono indicizzati in modo sincrono come indice speciale. Di conseguenza, la ricerca tramite l'identificatore di risorsa non è soggetta a ritardi di indicizzazione. Per utilizzare l'indice sincrono speciale, il termine di ricerca per l'identificatore deve corrispondere al pattern identifier=[system]|[value] o identifier=[value] e può essere utilizzato uno qualsiasi dei seguenti parametri dei risultati di ricerca:

  • _count
  • _include
  • _revinclude
  • _summary
  • _elements

Se la query contiene altri parametri di ricerca, verrà utilizzato l'indice asincrono standard. Tieni presente che la ricerca nell'indice speciale è ottimizzata per risolvere un numero ridotto di corrispondenze. La ricerca non è ottimizzata se i criteri di ricerca degli identificatori corrispondono a un numero elevato (ovvero più di 2000) di risorse. Per una query di ricerca che corrisponde a un numero elevato di risorse, puoi evitare di utilizzare l'indice sincrono speciale includendo un parametro _sort aggiuntivo nella query. Utilizza _sort=-_lastUpdated se vuoi mantenere l'ordine di ordinamento predefinito.

Ricerca in tutti i tipi di risorse

Alcuni parametri di ricerca, indicati da un trattino basso iniziale come _id, si applicano a tutti i tipi di risorse. Questi parametri per tutte le risorse sono elencati nella specifica FHIR per il tipo di risorsa.

Quando utilizzi questi parametri di ricerca, puoi eseguire una ricerca in più tipi di risorse omettendo il tipo di risorsa dal percorso della richiesta. Ad esempio, l'utilizzo di GET .../fhir?_id=1234 anziché di GET .../fhir/Patient?_id=1234 esegue ricerche in tutte le risorse FHIR anziché solo in una risorsa Patient. Puoi utilizzare il parametro speciale _type con questo tipo di richiesta per limitare i risultati a un elenco di tipi di risorse separati da virgole. Ad esempio, la seguente query restituisce solo risultati corrispondenti per le risorse Observation e Condition:

GET .../fhir?_tag=active&_type=Observation,Condition

Tipi di dati

Ogni parametro di ricerca definito da FHIR ha un tipo di dati, che include tipi primitivi come i seguenti:

  • Stringa
  • Numero
  • Data

I tipi di dati includono anche i seguenti tipi complessi:

  • Token
  • Riferimento
  • Quantità

Ogni tipo di dati ha una propria sintassi per specificare i valori. Ogni tipo di dati supporta modificatori che alterano la modalità di esecuzione della ricerca.

Le sezioni seguenti mostrano come utilizzare i tipi di dati. Per ulteriori dettagli su tipi di dati, sintassi dei valori e modificatori aggiuntivi, consulta la sezione Funzionalità di ricerca FHIR avanzate.

Numero

Ricerche su valori interi o in virgola mobile. Per modificare il comparatore, aggiungi al valore uno dei seguenti modificatori:

  • ne
  • lt
  • le
  • gt
  • ge

Ad esempio, utilizza [parameter]=100 per l'uguaglianza o [parameter]=ge100 per maggiore o uguale a 100.

Data

Ricerche su qualsiasi tipo di data, ora o periodo. Il formato del parametro data è il seguente:

yyyy-mm-ddThh:mm:ss[Z|(+|-)hh:mm]

Si applicano gli stessi modificatori del prefisso utilizzati per il numero.

Stringa

Per impostazione predefinita, viene eseguita una ricerca con prefisso che non fa distinzione tra maiuscole e minuscole, accenti o altri segni diacritici.

Token

Ricerche di una corrispondenza esatta di una "stringa". Puoi limitare la ricerca all'URI di un "sistema" che indica il valore impostato da cui viene preso il codice utilizzando il seguente formato:

[parameter]=[system]|[code]

Ad esempio, la seguente ricerca corrisponde a un codice 10738-3, ma solo se qualificato come valore di un sistema di codifica con l'URI specificato:

code=http://hl7.org/fhir/ValueSet/observation-codes|10738-3

Quantità

Cerca un valore numerico utilizzando gli stessi modificatori del prefisso di number. Puoi qualificare la ricerca con un sistema e un codice specifici che indicano le unità del valore nel seguente formato:

[parameter]=[prefix][number]|[system]|[code]

Ad esempio, la seguente query cerca valori di quantità inferiori a 9,1 con il sistema e il codice unità specificati:

value-quantity=lt9.1|http://unitsofmeasure.org|mg

Riferimento

Cerca i riferimenti tra le risorse. Puoi utilizzare le seguenti query per i riferimenti alle risorse all'interno di un archivio FHIR:

  • [parameter]=[id]
  • [parameter]=[type]/[id]

Puoi utilizzare [parameter]=[url] per specificare riferimenti per URL che potrebbero trovarsi al di fuori del datastore FHIR.

Gestione dei parametri di ricerca

Per impostazione predefinita, il metodo di ricerca applica la gestione "permissiva", che ignora i parametri non riconosciuti dalla ricerca. Il metodo di ricerca esegue la ricerca utilizzando tutti i parametri rimanenti nella richiesta, il che potrebbe restituire più risorse del previsto.

La risposta include quanto segue:

  • Un valore in Bundle.link con un valore di Bundle.link.relation = self
  • Un Bundle.link.url di un URL contenente solo i parametri che sono stati applicati correttamente alla ricerca. Puoi esaminare questo valore per determinare se alcuni parametri sono stati ignorati.

Puoi impostare l'intestazione HTTP della richiesta su Prefer: handling=strict in una richiesta di ricerca. L'impostazione dell'intestazione fa sì che il datastore FHIR restituisca un errore per qualsiasi parametro non riconosciuto.