Rechercher des ressources FHIR

Cette page décrit les instructions de base relatives à la recherche de ressources FHIR dans un magasin FHIR. La recherche de ressources FHIR est le principal moyen d'interroger et d'obtenir des insights à partir de données FHIR.

Vous pouvez rechercher des ressources FHIR dans l'API Cloud Healthcare de différentes manières:

• Utiliser le lecteur FHIR dans Cloud Console
• Utiliser la méthode projects.locations.datasets.fhirStores.fhir.search La méthode propose les méthodes suivantes pour rechercher des ressources FHIR :
  • Requêtes GET
  • Requêtes POST

Cette page récapitule de nombreuses fonctionnalités de recherche couramment utilisées, mais il ne s'agit pas d'une liste exhaustive des parties de la spécification de recherche FHIR acceptée par l'API Cloud Healthcare.

Utiliser le lecteur FHIR

Aperçu

Cette section décrit les fonctionnalités bêta susceptibles d'être modifiées et de compatibilité limitée. Les modifications apportées aux produits et fonctionnalités pré-DG peuvent ne pas être compatibles avec d'autres versions pré-DG. Pour en savoir plus, consultez les conditions de l'offre pré-DG pour l'API Cloud Healthcare et les descriptions des étapes de lancement.

Le lecteur FHIR est une page de Cloud Console qui vous permet de rechercher et d'afficher le contenu des ressources FHIR.

Pour rechercher des ressources dans un magasin FHIR, procédez comme suit:

1. Dans Cloud Console, accédez à la page du lecteur FHIR.

   Accéder au lecteur FHIR

2. Dans la liste déroulante Magasin FHIR, sélectionnez un ensemble de données, puis sélectionnez un magasin FHIR dans l'ensemble de données.

3. Pour filtrer la liste des types de ressources, recherchez les types de ressources que vous souhaitez afficher:

   1. Cliquez sur le champ Resource Type (Type de ressource).

   2. Dans la liste déroulante Propriétés qui s'affiche, sélectionnez Type de ressource.

   3. Saisissez un type de ressource.

   4. Pour rechercher un autre type de ressource, sélectionnez OU dans la liste déroulante Opérateurs qui s'affiche, puis saisissez un autre type de ressource.

4. Dans la liste des types de ressources, sélectionnez celui sur lequel vous souhaitez effectuer la recherche.

5. Dans le champ de recherche du tableau des ressources qui s'affiche, saisissez la valeur que vous souhaitez rechercher.

Le lecteur FHIR affiche les résultats de recherche dans une table. Une fois que vous avez sélectionné une ressource, le lecteur FHIR affiche son contenu.

Lorsque vous affichez le contenu d'une ressource, vous pouvez rechercher des données dans la ressource.

Pour rechercher des données dans une ressource, procédez comme suit:

1. Sélectionnez une ressource.

2. Dans le volet Visionneuse FHIR, cliquez sur l'onglet Éléments.

3. Dans le champ de recherche, saisissez la valeur à rechercher.

Utiliser la méthode search

Pour rechercher des ressources FHIR avec l'API REST, utilisez la méthode projects.locations.datasets.fhirStores.fhir.search. Vous pouvez appeler la méthode à l'aide des requêtes GET ou POST.

Utiliser la méthode search avec GET

Les exemples suivants montrent comment rechercher des ressources dans un datastore FHIR donné à l'aide de la méthode projects.locations.datasets.fhirStores.fhir.search avec GET.

curl

Pour rechercher des ressources dans un datastore FHIR, envoyez une requête GET et spécifiez les informations suivantes :

• Le nom de l'ensemble de données
• Le nom du datastore FHIR
• Le type de ressource à rechercher
• Une chaîne de requête contenant les informations que vous recherchez, comme décrit dans la section Créer une requête de recherche
• Un jeton d'accès

L'exemple suivant montre une requête GET utilisant curl pour rechercher tous les patients portant le nom de famille "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"

Si la requête aboutit, le serveur renvoie la réponse en tant que Bundle FHIR au format JSON. Le Bundle.type est searchset et les résultats de recherche sont des entrées du tableau Bundle.entry. Dans cet exemple, la requête renvoie une seule ressource "Patient" incluant les données qu'elle contient :

{
  "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

Pour rechercher des ressources dans un datastore FHIR, envoyez une requête GET et spécifiez les informations suivantes :

• Le nom de l'ensemble de données
• Le nom du datastore FHIR
• Le type de ressource à rechercher
• Une chaîne de requête contenant les informations que vous recherchez, comme décrit dans la section Créer une requête de recherche
• Un jeton d'accès

L'exemple suivant montre une requête GET utilisant Windows PowerShell pour rechercher tous les patients portant le nom de famille "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

Si la requête aboutit, le serveur renvoie la réponse en tant que Bundle FHIR au format JSON. Le Bundle.type est searchset et les résultats de recherche sont des entrées du tableau Bundle.entry. Dans cet exemple, la requête renvoie une seule ressource "Patient" incluant les données qu'elle contient :

{
  "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

Afficher sur GitHub Commentaires

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.jackson2.JacksonFactory;
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.impl.client.HttpClients;

public class FhirResourceSearchGet {
  private static final String FHIR_NAME =
      "projects/%s/locations/%s/datasets/%s/fhirStores/%s/fhir/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  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", "store-id", "resource-type");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%sv1/%s", client.getRootUrl(), resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());

    HttpUriRequest request =
        RequestBuilder.get()
            .setUri(uriBuilder.build())
            .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 GET FHIR resources: %s\n", response.getStatusLine().toString()));
      responseEntity.writeTo(System.err);
      throw new RuntimeException();
    }
    System.out.println("FHIR resource 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

Afficher sur GitHub Commentaires

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});

const searchFhirResourcesGet = async () => {
  // 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 parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir`;
  const request = {parent, resourceType};

  const response =
    await healthcare.projects.locations.datasets.fhirStores.fhir.search(
      request
    );
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesGet();

Python

Afficher sur GitHub Commentaires

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/master/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 = "{}/projects/{}/locations/{}".format(base_url, project_id, 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

Utiliser la méthode search avec POST

Les exemples suivants montrent comment rechercher des ressources dans un datastore FHIR donné à l'aide de la méthode projects.locations.datasets.fhirStores.fhir.search avec POST.

curl

Pour rechercher des ressources dans un datastore FHIR, envoyez une requête POST et spécifiez les informations suivantes :

• Le nom de l'ensemble de données
• Le nom du datastore FHIR
• Le type de ressource à rechercher
• Une chaîne de requête contenant les informations que vous recherchez, comme décrit dans la section Créer une requête de recherche
• Un jeton d'accès

L'exemple suivant montre une requête POST utilisant curl pour rechercher tous les patients portant le nom de famille "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"

Si la requête aboutit, le serveur renvoie la réponse en tant que Bundle FHIR au format JSON. Le Bundle.type est searchset et les résultats de recherche sont des entrées du tableau Bundle.entry. Dans cet exemple, la requête renvoie une seule ressource "Patient" incluant les données qu'elle contient :

{
  "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

Pour rechercher des ressources dans un datastore FHIR, envoyez une requête POST et spécifiez les informations suivantes :

• Le nom de l'ensemble de données
• Le nom du datastore FHIR
• Le type de ressource à rechercher
• Une chaîne de requête contenant les informations que vous recherchez, comme décrit dans la section Créer une requête de recherche
• Un jeton d'accès

L'exemple suivant montre une requête POST utilisant Windows PowerShell pour rechercher tous les patients portant le nom de famille "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

Si la requête aboutit, le serveur renvoie la réponse en tant que Bundle FHIR au format JSON. Le Bundle.type est searchset et les résultats de recherche sont des entrées du tableau Bundle.entry. Dans cet exemple, la requête renvoie une seule ressource "Patient" incluant les données qu'elle contient :

{
  "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

Afficher sur GitHub Commentaires

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.jackson2.JacksonFactory;
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";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  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");

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    HttpClient httpClient = HttpClients.createDefault();
    String uri = String.format("%sv1/%s/_search", client.getRootUrl(), resourceName);
    URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());
    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 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

Afficher sur GitHub Commentaires

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
  method: 'POST',
});

const searchFhirResourcesPost = async () => {
  // 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 parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/fhirStores/${fhirStoreId}/fhir`;
  const request = {parent, resourceType};

  const response =
    await healthcare.projects.locations.datasets.fhirStores.fhir.search(
      request
    );
  const resources = response.data.entry;
  console.log(`Resources found: ${resources.length}`);
  console.log(JSON.stringify(resources, null, 2));
};

searchFhirResourcesPost();

Python

Afficher sur GitHub Commentaires

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/master/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 = "{}/projects/{}/locations/{}".format(base_url, project_id, location)

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

    resource_path = "{}/Patient/_search?family:exact=Smith".format(fhir_store_path)

    # 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

Créer une requête de recherche

La chaîne de requête est une série de paires name=value encodées sous forme d'URL. Une recherche combine toutes les paires avec un AND logique. Chaque valeur peut être une liste de valeurs séparées par des virgules, qui sont traitées comme un OR logique de ces valeurs. Par exemple, Patient?key1=value1&key2=value2,value3 est une recherche sur les ressources du patient qui utilise les critères suivants:

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

Il n'y a pas de syntaxe pour effectuer un OR de deux paires name=value.

Chaque type de ressource FHIR définit ses propres paramètres de recherche dans chaque version de FHIR. Les paramètres disponibles sont documentés dans la spécification FHIR de chaque ressource. Pour obtenir un exemple, consultez FHIR R4 Patient. Vous pouvez récupérer les paramètres par programmation à l'aide de l'instruction de capacité. L'API Cloud Healthcare est compatible avec la plupart des paramètres de recherche. Vous trouverez des exclusions via la déclaration de capacité ou la déclaration de conformité FHIR.

Pagination et tri

Le paramètre _count contrôle le nombre maximal de ressources renvoyées par la méthode de recherche. Par exemple, _count=10 renvoie au maximum 10 ressources correspondant à la requête. La valeur par défaut est 100 et la valeur maximale autorisée est 1 000.

Si une recherche renvoie plus de ressources qu'une seule page, la réponse inclut une URL de pagination dans le champ Bundle.link. Ce champ peut comporter plusieurs valeurs. La valeur Bundle.link.relation = next indique que vous pouvez utiliser Bundle.link.url pour extraire la page suivante.

La valeur de Bundle.total indique le nombre total de ressources correspondantes. Cette valeur est exacte si les résultats s'affichent entièrement sur une seule page, mais qu'ils deviennent une estimation approximative à mesure que le nombre de résultats dépasse une page. Vous pouvez obtenir un total exact pour une recherche qui correspond à de nombreux résultats, en suivant à plusieurs reprises les liens de pagination jusqu'à ce que les résultats soient épuisés.

Vous pouvez trier les résultats à l'aide du paramètre _sort, qui accepte une liste de noms de paramètres de recherche séparés par une virgule, classés par ordre de priorité. Vous pouvez utiliser un préfixe - pour indiquer l'ordre décroissant. Par exemple, la requête suivante trie par ordre croissant d'état, casse les égalités par date dans l'ordre décroissant et casse les égalités restantes par catégorie dans l'ordre croissant:

_sort=status,-date,category

Remarque :Un datastore FHIR configuré pour utiliser la version DSTU2 utilise une syntaxe _sort différente présente dans cette version de la spécification. Chaque instance de _sort utilise un paramètre de recherche et un modificateur facultatif de :asc ou :desc. Par exemple, dans DSTU2, pour effectuer le même ordre de tri que l'exemple précédent, utilisez _sort=status&_sort:desc=date&_sort=category.

Délai d'indexation

Les ressources FHIR sont indexées de manière asynchrone. Il peut donc y avoir un léger décalage entre le moment où une ressource est créée ou modifiée et le moment où la création ou la modification est reflétée dans les résultats de recherche.

Rechercher dans tous les types de ressources

Certains paramètres de recherche, précédés d'un trait de soulignement comme _id, s'appliquent à tous les types de ressources. Ces paramètres de toutes les ressources sont répertoriés dans la spécification FHIR du type de ressource.

Lorsque vous utilisez ces paramètres de recherche, vous pouvez effectuer une recherche sur plusieurs types de ressources en omettant le type de ressource dans le chemin de la requête. Par exemple, l'utilisation de GET .../fhir?_id=1234 au lieu de GET .../fhir/Patient?_id=1234 recherche toutes les ressources FHIR au lieu d'une seule ressource Patient. Vous pouvez utiliser le paramètre spécial _type avec ce type de requête pour limiter les résultats à une liste de types de ressources séparés par des virgules. Par exemple, la requête suivante renvoie uniquement les résultats correspondants pour les ressources Observation et Condition:

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

Types de données

Chaque paramètre de recherche défini par FHIR possède un type de données qui inclut des types primitifs tels que les suivants:

• Chaîne
• Nombre
• Date

Les types de données comprennent également les types complexes suivants:

• Jeton
• Référence
• Quantité

Chaque type de données possède sa propre syntaxe pour spécifier les valeurs. Chaque type de données accepte les modificateurs qui modifient le mode de recherche.

Les sections suivantes expliquent comment utiliser les types de données. Pour en savoir plus sur les types de données supplémentaires, les syntaxes de valeurs et les modificateurs, consultez la page Fonctionnalités de recherche FHIR avancées.

Nombre

Recherche des valeurs entières ou à virgule flottante. Pour modifier le comparateur, préfixez la valeur avec l'un des modificateurs suivants:

• ne
• lt
• le
• gt
• ge

Par exemple, utilisez [parameter]=100 pour l'égalité ou [parameter]=ge100 pour une valeur supérieure ou égale à 100.

Date

Recherche sur n'importe quel type de date, d'heure ou de période. Le format du paramètre de date est le suivant:

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

Les mêmes modificateurs de préfixe que ceux utilisés pour number s'appliquent.

Chaîne

La valeur par défaut est une recherche de préfixe non sensible à la casse, aux accents ou à d'autres marques diacritiques.

Remarque :Les caractères de ponctuation divisent une recherche en plusieurs mots et les caractères de ponctuation eux-mêmes sont ignorés.

Jeton

Recherche une correspondance de chaîne exacte d'un "code". Vous pouvez limiter la recherche à l'URI d'un "système" indiquant que la valeur de l'ensemble de code est issue du format suivant:

[parameter]=[system]|[code]

Par exemple, la recherche suivante correspond à un code 10738-3, mais seulement sous forme de valeur issue d'un système de codage avec l'URI spécifié:

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

Quantité

Recherche une valeur numérique avec les mêmes modificateurs de préfixe que nombre. Vous pouvez qualifier la recherche avec un système spécifique et un code indiquant les unités de la valeur au format suivant:

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

Par exemple, la requête suivante recherche des valeurs de quantité inférieures à 9,1 qui présentent le système d'unité et le code spécifiés:

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

Référence

Recherche les références entre les ressources. Vous pouvez utiliser les requêtes suivantes pour faire référence à des ressources situées dans un magasin FHIR:

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

Vous pouvez utiliser [parameter]=[url] pour spécifier des références par URL qui peuvent se trouver en dehors du magasin FHIR.

Gestion des paramètres de recherche

Par défaut, la méthode de recherche applique la gestion "lentive", qui ignore les paramètres non reconnus par la recherche. La méthode de recherche effectue la recherche à l'aide des paramètres restants dans la requête, qui peuvent renvoyer plus de ressources que prévu.

La réponse inclut les éléments suivants:

• Une valeur dans Bundle.link avec la valeur Bundle.link.relation = self
• Le paramètre Bundle.link.url d'une URL contenant uniquement les paramètres qui ont bien été appliqués à la recherche. Vous pouvez inspecter cette valeur pour déterminer si des paramètres ont été ignorés.

Vous pouvez définir l'en-tête HTTP de la requête sur Prefer: handling=strict dans une requête de recherche. Lorsque vous définissez l'en-tête, le magasin FHIR renvoie une erreur sur un paramètre non reconnu.

Remarque : Définir l'option de datastore FIHR defaultSearchHandlingStrict remplace cette valeur par défaut par strict pour toutes les requêtes de recherche, sauf si une requête individuelle utilise l'en-tête HTTP Prefer: handling=lenient pour appliquer un traitement indulgent.