Buscar recursos de FHIR

En esta página, se explican las instrucciones básicas para buscar recursos de FHIR en un almacén de FHIR. La búsqueda de recursos de FHIR es la principal forma de consultar y obtener estadísticas de los datos de FHIR.

Puedes buscar recursos de FHIR en la API de Cloud Healthcare de las siguientes maneras:

• Usar el visualizador de FHIR en Cloud Console
• Usando el método projects.locations.datasets.fhirStores.fhir.search El método proporciona las siguientes maneras de buscar recursos de FHIR:
  • Solicitudes GET
  • Solicitudes POST

En esta página, se resumen muchas de las funciones de búsqueda de uso común, pero no es una lista exhaustiva de partes de la especificación de búsqueda de FHIR compatible con la API de Cloud Healthcare.

Usar el visor de FHIR

Vista previa

En esta sección, se describen las funciones de vista previa que están sujetas a cambios y que pueden ser limitadas. Es posible que los cambios en los productos y las características en fase previa a la DG no sean compatibles con otras versiones de la fase previa a la DG. Para obtener más información, consulta las Condiciones de las ofertas de la fase previa a la DG de la API de Cloud Healthcare y las descripciones de la etapa de lanzamiento.

El visor de FHIR es una página de Cloud Console que te permite buscar y ver el contenido de los recursos de FHIR.

Para buscar recursos en un almacén de FHIR, sigue estos pasos:

1. En Cloud Console, ve a la página Visor de FHIR.

   Ir al visualizador de FHIR

2. En la lista desplegable Almacén de FHIR, selecciona un conjunto de datos y, luego, selecciona un almacén de FHIR en el conjunto de datos.

3. Para filtrar la lista de tipos de recursos, busca los tipos de recursos que deseas mostrar:

   1. Haz clic en el campo Resource Type (Tipo de recurso).

   2. En la lista desplegable Propiedades que aparece, selecciona Tipo de recurso.

   3. Ingresa un tipo de recurso.

   4. Para buscar otro tipo de recurso, selecciona O en la lista desplegable Operadores que aparece y, luego, ingresa otro tipo de recurso.

4. En la lista de tipos de recursos, selecciona el tipo de recurso que deseas buscar.

5. En el cuadro de búsqueda de la tabla de recursos que aparece, ingresa el valor que deseas buscar.

El visor de FHIR muestra los resultados de la búsqueda en una tabla. Después de seleccionar un recurso, el visor de FHIR muestra el contenido del recurso.

Cuando visualizas el contenido de un recurso, puedes buscar datos dentro del recurso.

Para buscar datos dentro de un recurso, sigue estos pasos:

1. Selecciona un recurso.

2. En el panel FHIR Viewer, haz clic en la pestaña Elementos.

3. En el cuadro de búsqueda, ingresa el valor que desees buscar.

Usa el método search

Para buscar recursos de FHIR con la API de REST, usa el método projects.locations.datasets.fhirStores.fhir.search. Puedes llamar al método mediante solicitudes GET o POST.

Usa el método search con GET

En los siguientes ejemplos, se muestra cómo buscar recursos en una tienda de FHIR determinada mediante el método projects.locations.datasets.fhirStores.fhir.search con GET.

curl

Para buscar recursos en una tienda de FHIR, realiza una solicitud GET y especifica la siguiente información:

• El nombre del conjunto de datos
• El nombre de la tienda de FHIR
• El tipo de recurso que deseas buscar
• Una string de consulta que contiene la información que buscas, como se describe en la sección Cómo construir una búsqueda
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl para buscar todos los pacientes con el apellido "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 solicitud es exitosa, el servidor mostrará la respuesta como un Bundle de FHIR en formato JSON. Bundle.type es searchset y los resultados de la búsqueda son entradas en el arreglo Bundle.entry. En este ejemplo, la solicitud muestra un solo recurso Patient que incluye los datos dentro de ese recurso:

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

Para buscar recursos en una tienda de FHIR, realiza una solicitud GET y especifica la siguiente información:

• El nombre del conjunto de datos
• El nombre de la tienda de FHIR
• El tipo de recurso que deseas buscar
• Una string de consulta que contiene la información que buscas, como se describe en la sección Cómo construir una búsqueda
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell para buscar todos los pacientes con el apellido "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 solicitud es exitosa, el servidor mostrará la respuesta como un Bundle de FHIR en formato JSON. Bundle.type es searchset y los resultados de la búsqueda son entradas en el arreglo Bundle.entry. En este ejemplo, la solicitud muestra un solo recurso Patient que incluye los datos dentro de ese recurso:

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

Ver en GitHub Comentarios

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

Ver en GitHubComentarios

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

Ver en GitHubComentarios

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

Usa el método search con POST

En los siguientes ejemplos, se muestra cómo buscar recursos en una tienda de FHIR determinada mediante el método projects.locations.datasets.fhirStores.fhir.search con POST.

curl

Para buscar recursos en una tienda de FHIR, realiza una solicitud POST y especifica la siguiente información:

• El nombre del conjunto de datos
• El nombre de la tienda de FHIR
• El tipo de recurso que deseas buscar
• Una string de consulta que contiene la información que buscas, como se describe en la sección Cómo construir una búsqueda
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante curl para buscar todos los pacientes con el apellido "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 solicitud es exitosa, el servidor mostrará la respuesta como un Bundle de FHIR en formato JSON. Bundle.type es searchset y los resultados de la búsqueda son entradas en el arreglo Bundle.entry. En este ejemplo, la solicitud muestra un solo recurso Patient que incluye los datos dentro de ese recurso:

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

Para buscar recursos en una tienda de FHIR, realiza una solicitud POST y especifica la siguiente información:

• El nombre del conjunto de datos
• El nombre de la tienda de FHIR
• El tipo de recurso que deseas buscar
• Una string de consulta que contiene la información que buscas, como se describe en la sección Cómo construir una búsqueda
• Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell para buscar todos los pacientes con el apellido "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 solicitud es exitosa, el servidor mostrará la respuesta como un Bundle de FHIR en formato JSON. Bundle.type es searchset y los resultados de la búsqueda son entradas en el arreglo Bundle.entry. En este ejemplo, la solicitud muestra un solo recurso Patient que incluye los datos dentro de ese recurso:

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

Ver en GitHub Comentarios

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

Ver en GitHubComentarios

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

Ver en GitHubComentarios

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

Cómo crear una búsqueda

La cadena de consulta es una serie de pares name=value codificados con el formato de una URL. Una búsqueda combina todos los pares con un AND lógico. Cada valor puede ser una lista de valores separados por comas, que se tratan como un OR lógico de esos valores. Por ejemplo, Patient?key1=value1&key2=value2,value3 es una búsqueda en recursos de pacientes que usa los siguientes criterios:

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

No hay sintaxis para realizar una OR de dos pares name=value.

Cada tipo de recurso de FHIR define sus propios parámetros de búsqueda en cada versión de FHIR. Los parámetros disponibles se documentan en la especificación de FHIR de cada recurso. Para ver un ejemplo, consulta Paciente de FHIR R4. Puedes recuperar los parámetros de manera programática a través de la declaración de capacidad. La API de Cloud Healthcare admite la mayoría de los parámetros de búsqueda. Puedes encontrar exclusiones a través de la declaración de capacidad o de la declaración de cumplimiento de FHIR.

Paginación y ordenamiento

El parámetro _count controla la cantidad máxima de recursos que se muestran en el método de búsqueda. Por ejemplo, _count=10 muestra, como máximo, 10 recursos que coinciden con la consulta. El valor predeterminado es 100 y el valor máximo permitido es 1,000.

Si una búsqueda muestra más recursos que los que caben en una página, la respuesta incluye una URL de paginación en el campo Bundle.link. Es posible que se muestren varios valores en este campo. El valor con Bundle.link.relation = next indica que puedes usar el Bundle.link.url correspondiente para recuperar la página siguiente.

El valor de Bundle.total indica la cantidad total de recursos coincidentes. Este valor es exacto si los resultados se ajustan por completo a una página, pero se convierte en una estimación aproximada a medida que el número de resultados se incrementa en una página. Puedes obtener un total exacto de una búsqueda que coincida con muchos resultados si sigues los vínculos de paginación de forma repetida hasta que los resultados se agotan.

Puedes ordenar los resultados con el parámetro _sort, que acepta una lista separada por comas de los nombres de los parámetros de búsqueda en orden de prioridad. Puedes usar un prefijo - para indicar el orden descendente. Por ejemplo, con la siguiente consulta, se ordena el estado de forma ascendente, se rompe la relación por fecha descendente y se elimina cualquier laboración restante por categoría ascendente:

_sort=status,-date,category

Nota: Un almacén de FHIR configurado para usar la versión de DSTU2 usa una sintaxis _sort diferente de la versión de la especificación. Cada instancia de _sort toma un parámetro de búsqueda y un modificador opcional de :asc o :desc. Por ejemplo, en DSTU2, para realizar el mismo orden de clasificación que en el ejemplo anterior, usa _sort=status&_sort:desc=date&_sort=category.

Demora en la indexación

Los recursos de FHIR se indexan de forma asíncrona, por lo que puede haber un ligero retraso entre el momento en que un recurso se crea o se modifica y el momento en que la creación o el cambio se reflejan en los resultados de la búsqueda.

Busca en todos los tipos de recursos

Algunos parámetros de búsqueda, que se muestran con un guion bajo inicial como _id, se aplican a todos los tipos de recursos. Estos parámetros de todos los recursos se enumeran en la especificación de FHIR para el Tipo de recurso.

Cuando usas estos parámetros de búsqueda, puedes realizar una búsqueda en varios tipos de recursos si omites el tipo de recurso en la ruta de la solicitud. Por ejemplo, usar GET .../fhir?_id=1234 en lugar de GET .../fhir/Patient?_id=1234 realiza búsquedas en todos los recursos de FHIR en lugar de solo en un recurso de paciente. Puedes usar el parámetro especial _type con este tipo de solicitud para limitar los resultados a una lista de tipos de recursos separados por comas. Por ejemplo, la siguiente consulta solo muestra resultados coincidentes para los recursos Observation y Condition:

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

Tipos de datos

Cada parámetro de búsqueda definido por FHIR tiene un tipo de datos, incluidos los tipos primitivos, como los siguientes:

• String
• Número
• Fecha

Los tipos de datos también incluyen los siguientes tipos complejos:

• Token
• Referencia
• Cantidad

Cada tipo de datos tiene su propia sintaxis para especificar valores. Cada tipo de datos admite modificadores que alteran la forma en que se realiza la búsqueda.

En las siguientes secciones, se muestra cómo usar los tipos de datos. Para obtener más detalles sobre los tipos de datos adicionales, las sintaxis de valores y los modificadores, consulta Funciones de búsqueda avanzada de FHIR.

Número

Busca valores de número entero o de punto flotante. Para cambiar el comparador, agrégale el prefijo con uno de los siguientes modificadores:

• ne
• lt
• le
• gt
• ge

Por ejemplo, usa [parameter]=100 para la igualdad o [parameter]=ge100 para el valor mayor o igual que 100.

Fecha

Busca en cualquier tipo de fecha, hora o período. El formato del parámetro de fecha es el siguiente:

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

Se aplican los mismos modificadores de prefijo que se usan para número.

String

La configuración predeterminada es una búsqueda de prefijos que no distingue entre mayúsculas y minúsculas, acentos y otras marcas diacríticas.

Nota: Los caracteres de puntuación dividen una búsqueda en varias palabras y los caracteres de puntuación se ignoran.

Token

Busca una coincidencia de string exacta de un "código". Puedes determinar el alcance de la búsqueda con el URI de un "sistema" que indique el valor del que se toma el código con el siguiente formato:

[parameter]=[system]|[code]

Por ejemplo, la siguiente búsqueda coincide con un código de 10738-3, pero solo cuando se califica como un valor de un sistema de codificación con el URI especificado:

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

Cantidad

Busca un valor numérico con los mismos modificadores de prefijo que number. Puedes calificar la búsqueda con un sistema y un código específicos que indiquen las unidades del valor en el siguiente formato:

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

Por ejemplo, la siguiente consulta busca valores de cantidad inferiores a 9.1 que tienen el sistema de unidades y el código especificados:

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

Referencia

Busca referencias entre recursos. Puedes usar las siguientes consultas para obtener referencias a los recursos dentro de un almacén de FHIR:

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

Puedes usar [parameter]=[url] para especificar referencias por URL que pueden estar fuera del almacén de FHIR.

Busca en la organización de parámetros

De forma predeterminada, el método de búsqueda aplica el control "leniento", que ignora los parámetros que la búsqueda no reconoce. El método de búsqueda realiza la búsqueda con cualquier parámetro restante en la solicitud, lo que podría mostrar más recursos de lo esperado.

La respuesta incluye lo siguiente:

• Un valor en Bundle.link con un valor de Bundle.link.relation = self
• Una Bundle.link.url de una URL que contiene solo los parámetros que se aplicaron de forma correcta a la búsqueda Puedes inspeccionar este valor para determinar si se omitió algún parámetro.

Puedes configurar el encabezado HTTP de la solicitud como Prefer: handling=strict en una solicitud de búsqueda. Configurar el encabezado hace que el almacén de FHIR muestre un error en cualquier parámetro que no se reconozca.

Nota: Si se configura la opción defaultSearchHandlingStrict del almacén de FHIR, se cambia este valor predeterminado a strict para todas las solicitudes de búsqueda, a menos que una solicitud individual use el encabezado HTTP Prefer: handling=lenient a fin elegir la opción indulgente.