Esta página se ha traducido con Cloud Translation API.
Switch to English

Crea y administra mensajes HL7v2

En esta página, se explica cómo transferir, crear, etiquetar, enumerar, ver y borrar mensajes HL7v2.

Descripción general de la creación y la transferencia de mensajes de HL7v2

El método messages.create se usa para almacenar un mensaje de HL7v2 en la API de Cloud Healthcare.

El método messages.ingest también se usa para almacenar un mensaje de HL7v2 en la API de Cloud Healthcare. Sin embargo, también genera una respuesta que contiene un mensaje de confirmación de recepción de HL7v2 ( ACK ) cuando tenga éxito o un mensaje de confirmación negativa (NACK ) en caso de error, adecuado para responder a los sistemas de interfaz de HL7v2 que esperan estas confirmaciones de recepción.

Creación y transferencia de mensajes con un adaptador de MLLP

Los mensajes HL7v2 se entregan entre los sistemas de atención y la API de Cloud Healthcare mediante el protocolo de capa inferior mínima (MLLP). Para obtener más información, consulta MLLP y el adaptador de MLLP de Google Cloud Platform. Si deseas obtener instrucciones sobre cómo configurar un adaptador de MLLP para que se comunique de forma segura con la API de Cloud Healthcare, consulta Transmite mensajes HL7v2 a través de conexiones TCP/IP.

Transfiere mensajes de HL7v2

Después de que la API de Cloud Healthcare transfiere el mensaje desde un sistema de atención, la API de Cloud Healthcare genera una respuesta que contiene un campo hl7ack que contiene un mensaje de HL7v2 codificado en base64 con las siguientes características:

  • El tipo de mensaje es ACK.
  • Se revierten la instalación de envío y la de recepción, y se revierten la aplicación de envío y la aplicación de recepción.
  • La hora de envío del mensaje es la hora actual, y se genera un ID de control nuevo.
  • El valor del campo MSA.1 define un tipo de respuesta. Un tipo de respuesta AA indica Application Accept, lo que significa que el mensaje se validó y transfirió de forma correcta.
  • El valor MSA.2 contiene el ID de control del mensaje original.

En los siguientes ejemplos, se muestra cómo transferir un mensaje de HL7v2 con el método projects.locations.datasets.hl7V2Stores.messages.ingest.

curl

Para transferir un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un mensaje
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST con curl y un archivo JSON de ejemplo llamado hl7v2-sample.json.

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data-binary @hl7v2-sample.json \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages:ingest"

En la siguiente respuesta de ejemplo, se muestran los detalles de hl7Ack y del mensaje.

{
  "hl7Ack": "TVNIfF5+XCZ8QXxBfEF8U0VORF9GQUNJTElUWXwyMDIwMDIxNDIxMjAwNXx8QUNLfDFmMmQ1MjQzLTFhOWEtNGE4My05ZmI5LWNlNTIzMTVmZjk2M3xUfDAuMA1NU0F8QUF8MjAxODAxMDEwMDAwMDA=",
  "message": {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
    "sendFacility": "SEND_FACILITY",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "CREATE_TIME",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
  }
}

PowerShell

Para transferir un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un mensaje
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell y un archivo JSON de muestra llamado hl7v2-sample.json.

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

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile hl7v2-sample.json `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages:ingest" | Select-Object -Expand Content

En la siguiente respuesta de ejemplo, se muestran los detalles de hl7Ack y del mensaje.

{
  "hl7Ack": "TVNIfF5+XCZ8QXxBfEF8U0VORF9GQUNJTElUWXwyMDIwMDIxNDIxMjAwNXx8QUNLfDFmMmQ1MjQzLTFhOWEtNGE4My05ZmI5LWNlNTIzMTVmZjk2M3xUfDAuMA1NU0F8QUF8MjAxODAxMDEwMDAwMDA=",
  "message": {
    "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
    "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
    "sendFacility": "SEND_FACILITY",
    "sendTime": "2018-01-01T00:00:00Z",
    "messageType": "TYPE",
    "createTime": "CREATE_TIME",
    "patientIds": [
      {
        "value": "14\u0001111",
        "type": "MRN"
      },
      {
        "value": "11111111",
        "type": "MRN"
      },
      {
        "value": "1111111111",
        "type": "ORGNMBR"
      }
    ]
  }
}

Go

import (
	"context"
	"encoding/base64"
	"fmt"
	"io"
	"io/ioutil"

	healthcare "google.golang.org/api/healthcare/v1"
)

// ingestHL7V2Message ingests an HL7V2 message.
func ingestHL7V2Message(w io.Writer, projectID, location, datasetID, hl7V2StoreID, messageFile string) error {
	ctx := context.Background()

	hl7v2message, err := ioutil.ReadFile(messageFile)
	if err != nil {
		return fmt.Errorf("ReadFile: %v", err)
	}

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	req := &healthcare.IngestMessageRequest{
		Message: &healthcare.Message{
			Data: base64.StdEncoding.EncodeToString(hl7v2message),
		},
	}
	parent := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s", projectID, location, datasetID, hl7V2StoreID)

	resp, err := messagesService.Ingest(parent, req).Do()
	if err != nil {
		return fmt.Errorf("Create: %v", err)
	}

	fmt.Fprintf(w, "Ingested HL7V2 message: %q\n", resp.Message.Name)
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.Hl7V2Stores.Messages;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.IngestMessageRequest;
import com.google.api.services.healthcare.v1.model.IngestMessageResponse;
import com.google.api.services.healthcare.v1.model.Message;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessageIngest {
  private static final String HL7v2_NAME = "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s";
  private static final String MESSAGE_NAME =
      "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessageIngest(String hl7v2StoreName, String filePath) throws IOException {
    // String hl7v2StoreName =
    //    String.format(
    //        HL7v2_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-hl7v2-id");

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

    // Load the data from file and format it into an ingest request.
    List<String> lines = Files.readAllLines(Paths.get(filePath), Charset.defaultCharset());
    String data = String.join("\n", lines);
    Message message = new Message().setData(data);
    IngestMessageRequest ingestRequest = new IngestMessageRequest().setMessage(message);

    // Create request and configure any parameters.
    Messages.Ingest request =
        client
            .projects()
            .locations()
            .datasets()
            .hl7V2Stores()
            .messages()
            .ingest(hl7v2StoreName, ingestRequest);

    // Execute the request and process the results.
    IngestMessageResponse response = request.execute();
    System.out.println("HL7v2 message ingested: " + response.toPrettyString());
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');
const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);

const ingestHl7v2Message = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  // const hl7v2MessageFile = 'hl7v2-message.json';
  const hl7v2Message = JSON.parse(await readFile(hl7v2MessageFile));

  const parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}`;
  const request = {parent, resource: hl7v2Message};

  const response = await healthcare.projects.locations.datasets.hl7V2Stores.messages.ingest(
    request
  );
  const data = response.data.hl7Ack;
  const buff = new Buffer.from(data, 'base64');
  const hl7Ack = buff.toString('ascii');
  console.log('Ingested HL7v2 message with ACK:\n', hl7Ack);
};

ingestHl7v2Message();

Python

def ingest_hl7v2_message(
    project_id, cloud_region, dataset_id, hl7v2_store_id, hl7v2_message_file
):
    """Ingests a new HL7v2 message from the hospital and sends a notification
    to the Cloud Pub/Sub topic. Return is an HL7v2 ACK message if the message
    was successfully stored.
    """
    client = get_client()
    hl7v2_parent = "projects/{}/locations/{}".format(project_id, cloud_region)
    hl7v2_store_name = "{}/datasets/{}/hl7V2Stores/{}".format(
        hl7v2_parent, dataset_id, hl7v2_store_id
    )

    with open(hl7v2_message_file) as hl7v2_message:
        hl7v2_message_content = json.load(hl7v2_message)

    request = (
        client.projects()
        .locations()
        .datasets()
        .hl7V2Stores()
        .messages()
        .ingest(parent=hl7v2_store_name, body=hl7v2_message_content)
    )

    response = request.execute()
    print("Ingested HL7v2 message from file: {}".format(hl7v2_message_file))
    return response

Crea mensajes de HL7v2

En los siguientes ejemplos, se muestra cómo crear un mensaje de HL7v2 con el método projects.locations.datasets.hl7V2Stores.messages.create.

curl

Para crear un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un mensaje Si necesitas un mensaje de HL7v2 de muestra para usar con los comandos de muestra, puedes descargar el archivo JSON hl7v2-sample.json.
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST con curl y un archivo JSON de ejemplo llamado hl7v2-sample.json.

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data-binary @hl7v2-sample.json \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "1970-01-01T00:00:00Z",
  "patientIds": [
    {
      "value": "14\u0001111",
      "type": "MRN"
    },
    {
      "value": "11111111",
      "type": "MRN"
    },
    {
      "value": "1111111111",
      "type": "ORGNMBR"
    }
  ]
}

PowerShell

Para crear un mensaje de HL7v2, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un mensaje Si necesitas un mensaje de HL7v2 de muestra para usar con los comandos de muestra, puedes descargar el archivo JSON hl7v2-sample.json.
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell y un archivo JSON de muestra llamado hl7v2-sample.json.

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

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile hl7v2-sample.json `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "TVNIfF5+XCZ8QXxTRU5EX0ZBQ0lMSVRZfEF8QXwyMDE4MDEwMTAwMDAwMHx8VFlQRV5BfDIwMTgwMTAxMDAwMDAwfFR8MC4wfHx8QUF8fDAwfEFTQ0lJDUVWTnxBMDB8MjAxODAxMDEwNDAwMDANUElEfHwxNAExMTFeXl5eTVJOfDExMTExMTExXl5eXk1STn4xMTExMTExMTExXl5eXk9SR05NQlI=",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "1970-01-01T00:00:00Z",
  "patientIds": [
    {
      "value": "14\u0001111",
      "type": "MRN"
    },
    {
      "value": "11111111",
      "type": "MRN"
    },
    {
      "value": "1111111111",
      "type": "ORGNMBR"
    }
  ]
}

Go

import (
	"context"
	"encoding/base64"
	"fmt"
	"io"
	"io/ioutil"

	healthcare "google.golang.org/api/healthcare/v1"
)

// createHL7V2Message creates an HL7V2 message.
func createHL7V2Message(w io.Writer, projectID, location, datasetID, hl7V2StoreID, messageFile string) error {
	ctx := context.Background()

	hl7v2message, err := ioutil.ReadFile(messageFile)
	if err != nil {
		return fmt.Errorf("ReadFile: %v", err)
	}

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	req := &healthcare.CreateMessageRequest{
		Message: &healthcare.Message{
			Data: base64.StdEncoding.EncodeToString(hl7v2message),
		},
	}
	parent := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s", projectID, location, datasetID, hl7V2StoreID)
	resp, err := messagesService.Create(parent, req).Do()
	if err != nil {
		return fmt.Errorf("Create: %v", err)
	}

	fmt.Fprintf(w, "Created HL7V2 message: %q\n", resp.Name)
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.Hl7V2Stores.Messages;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.CreateMessageRequest;
import com.google.api.services.healthcare.v1.model.Message;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessageCreate {
  private static final String HL7v2_NAME = "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessageCreate(String hl7v2StoreName, String messageId, String filePath)
      throws IOException {
    // String hl7v2StoreName =
    //    String.format(
    //        HL7v2_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-hl7v2-id");
    // String messageId = "your-message-id";
    // String filePath = "path/to/file.txt";

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

    // Load the data from file representing the message.
    List<String> lines = Files.readAllLines(Paths.get(filePath), Charset.defaultCharset());
    String data = String.join("\n", lines);
    Message message = new Message().setData(data).setName(messageId);
    CreateMessageRequest createRequest = new CreateMessageRequest().setMessage(message);

    // Create request and configure any parameters.
    Messages.Create request =
        client
            .projects()
            .locations()
            .datasets()
            .hl7V2Stores()
            .messages()
            .create(hl7v2StoreName, createRequest);

    // Execute the request and process the results.
    Message response = request.execute();
    System.out.println("HL7v2 message created: " + response.toPrettyString());
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');
const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);

const createHl7v2Message = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  // const hl7v2MessageFile = 'hl7v2-message.json';
  const hl7v2Message = JSON.parse(await readFile(hl7v2MessageFile));

  const parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}`;
  const request = {parent, resource: hl7v2Message};

  const response = await healthcare.projects.locations.datasets.hl7V2Stores.messages.create(
    request
  );
  const {data} = response;
  console.log('Created HL7v2 message with data:\n', data);
};

createHl7v2Message();

Python

def create_hl7v2_message(
    project_id, cloud_region, dataset_id, hl7v2_store_id, hl7v2_message_file
):
    """Creates an HL7v2 message and sends a notification to the
    Cloud Pub/Sub topic.
    """
    client = get_client()
    hl7v2_parent = "projects/{}/locations/{}".format(project_id, cloud_region)
    hl7v2_store_name = "{}/datasets/{}/hl7V2Stores/{}".format(
        hl7v2_parent, dataset_id, hl7v2_store_id
    )

    with open(hl7v2_message_file) as hl7v2_message:
        hl7v2_message_content = json.load(hl7v2_message)

    request = (
        client.projects()
        .locations()
        .datasets()
        .hl7V2Stores()
        .messages()
        .create(parent=hl7v2_store_name, body=hl7v2_message_content)
    )

    response = request.execute()
    print("Created HL7v2 message from file: {}".format(hl7v2_message_file))
    return response

Codificación y separadores de segmentos de los mensajes de HL7v2

El separador de segmento predeterminado en HL7v2 es un retorno de carro (\r). La mayoría de los editores de texto usan caracteres de salto de línea (\n) como separadores de segmentos. Esto produce mensajes HL7v2 que no se pueden transferir a la API de Cloud Healthcare mediante la configuración predeterminada. Para permitir que una tienda HL7v2 transfiera mensajes que usan caracteres de salto de línea como separadores de segmentos, consulta Configura el terminador de segmentos.

Para convertir los caracteres de salto de línea en un archivo a retorno de carro, ejecuta el siguiente comando en una shell de Linux:

sed -z 's/\n/\r/g' INPUT_FILENAME > OUTPUT_FILENAME

Los métodos de transferencia y creación esperan que los mensajes de HL7v2 sean strings codificadas en base64. Para convertir una string en codificación base64, ejecuta el siguiente comando en un shell de Linux:

openssl base64 -A -in ./INPUT_FILENAME -out ./OUTPUT_FILENAME

Configura el terminador de segmentos

Cuando creas o transfieres datos, el formato de mensaje de HL7v2 requiere que los segmentos finalicen con el carácter de retorno, \r. Puedes configurar un almacén de HL7v2 para aceptar mensajes de HL7v2 con un terminador no estándar, como \n.

Considera el siguiente mensaje de HL7v2 que usa el \r predeterminado como terminador de segmentos. Este mensaje se acepta de forma predeterminada cuando creas un almacén de HL7v2.

MSH|^~\\&|FROM_APP|FROM_FACILITY|TO_APP|TO_FACILITY|20150503223000||ADT^A01|20150503223000|P|2.5|\r
EVN|A01|20110613083617|\r
PID|1||21004053^^^^MRN||SULLY^BRIAN||19611209|M|||123 MAIN ST^^MOUNTAIN SPRINGS^CO^80439|\r
PV1||I|H73 RM1^1^^HIGHWAY 73 CLINIC||||5148^MARY QUINN|||||||||Y||||||||||||||||||||||||||||20150503223000|\r

El mensaje siguiente es idéntico al mensaje anterior, excepto que usa \n como terminador de segmentos:

MSH|^~\\&|FROM_APP|FROM_FACILITY|TO_APP|TO_FACILITY|20150503223000||ADT^A01|20150503223000|P|2.5|\n
EVN|A01|20110613083617|\n
PID|1||21004053^^^^MRN||SULLY^BRIAN||19611209|M|||123 MAIN ST^^MOUNTAIN SPRINGS^CO^80439|\n
PV1||I|H73 RM1^1^^HIGHWAY 73 CLINIC||||5148^MARY QUINN|||||||||Y||||||||||||||||||||||||||||20150503223000|\n

Para almacenar el mensaje con el terminador no estándar, configura el objeto ParserConfig en la tienda HL7v2 y establece el campo segmentTerminator en la codificación base64 de \n.

En los siguientes ejemplos, se muestra cómo configurar segmentTerminator en ParserConfig cuando creas un almacén de HL7v2. Si tienes un almacén de HL7v2 existente, puedes editarlo para proporcionar el cuerpo ParserConfig. Después de configurar el terminador de segmentos, puedes crear o transferir el mensaje.

curl

Para crear una tienda HL7v2 con el terminador de segmentos configurado en \n, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un objeto parserConfig con el segmentTerminator configurado como Cg== (la codificación base64 de \n)
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante curl.

curl -X POST \
    --data "{
      'parserConfig': {
        'segmentTerminator': 'Cg=='
      }
    }" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "parserConfig": {
    "segmentTerminator": "Cg=="
  }
}

PowerShell

Para crear una tienda HL7v2 con el terminador de segmentos configurado en \n, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un objeto parserConfig con el segmentTerminator configurado como Cg== (la codificación base64 de \n)
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'parserConfig': {
        'segmentTerminator': 'Cg=='
      }
  } `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "parserConfig": {
    "segmentTerminator": "Cg=="
  }
}

Usa un encabezado de segmento nulo

Un mensaje HL7v2 sin un segmento de encabezado de mensaje (MSH) tiene un encabezado de segmento nulo. Por lo general, un mensaje HL7v2 contiene un MSH que define metadatos como la fuente, el intent, el propósito y el destino del mensaje. El MSP te permite buscar y filtrar mensajes. Sin embargo, puedes almacenar mensajes que no contienen un MSH configura el objeto ParserConfig en el almacén HL7v2 y establece el campo allowNullHeader en true.

El siguiente mensaje de muestra contiene un segmento de identificación de pacientes (PID), pero sin MSH:

PID|1||21004053^^^^MRN||SULLY^BRIAN||19611209|M|||123 MAIN ST^^MOUNTAIN SPRINGS^CO^80439

En los siguientes ejemplos, se muestra cómo configurar allowNullHeader en ParserConfig cuando creas un almacén de HL7v2. Si tienes un almacén de HL7v2 existente, puedes editarlo y proporcionar el cuerpo ParserConfig. Después de configurar allowNullHeader como true, puedes crear o transferir mensajes con encabezados de segmentos nulos.

curl

Para crear una tienda HL7v2 y mensajes de almacenamiento que no contengan un MSH, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un objeto parserConfig con allowNullHeader configurado como true
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante curl.

curl -X POST \
    --data "{
      'parserConfig': {
        'allowNullHeader': true
      }
    }" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "parserConfig": {
    "allowNullHeader": true
  }
}

PowerShell

Para crear una tienda HL7v2 y mensajes de almacenamiento que no contengan un MSH, realiza una solicitud POST y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • Un objeto parserConfig con allowNullHeader configurado como true
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'parserConfig': {
        'nullTerminator': true
      }
  } `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores?hl7V2StoreId=HL7V2_STORE_ID" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID",
  "parserConfig": {
    "allowNullHeader": true
  }
}

Etiqueta un mensaje de HL7v2

Puedes agregar una o más etiquetas de clave-valor a un mensaje. Un caso práctico para las etiquetas es agregar etiquetas de estado a un mensaje con el fin de que una aplicación pueda consultar mensajes por estado.

En los siguientes ejemplos, se muestra cómo agregar etiquetas a un mensaje HL7v2 mediante el método projects.locations.datasets.hl7V2Stores.messages.patch.

curl

Para agregar etiquetas a un mensaje de HL7v2, realiza una solicitud PATCH y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • Los datos de la etiqueta que deseas actualizar
  • Una máscara de actualización
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud PATCH mediante curl.

curl -X PATCH \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'labels': {
        'KEY' : 'VALUE'
      }
    }" "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?updateMask=labels"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    }
  ],
  "labels": {
    "KEY": "VALUE"
  }
}

PowerShell

Para agregar etiquetas a un mensaje de HL7v2, realiza una solicitud PATCH y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • Los datos de la etiqueta que deseas actualizar
  • Una máscara de actualización
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud PATCH mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Patch `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
      'labels': {
        'KEY': 'VALUE'
      }
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?updateMask=labels" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    }
  ],
  "labels": {
    "KEY": "VALUE"
  }
}

Go

import (
	"context"
	"encoding/base64"
	"fmt"
	"io"
	"io/ioutil"

	healthcare "google.golang.org/api/healthcare/v1"
)

// patchHL7V2Message patches an HL7V2 message.
func patchHL7V2Message(w io.Writer, projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID, messageFile string) error {
	ctx := context.Background()

	hl7v2message, err := ioutil.ReadFile(messageFile)
	if err != nil {
		return fmt.Errorf("ReadFile: %v", err)
	}

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s", projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID)
	message := &healthcare.Message{
		Data:   base64.StdEncoding.EncodeToString(hl7v2message),
		Labels: map[string]string{"my-label": "true"},
	}

	call := messagesService.Patch(name, message)
	call.UpdateMask("labels")
	resp, err := call.Do()
	if err != nil {
		return fmt.Errorf("Patch: %v", err)
	}

	fmt.Fprintf(w, "Patched HL7V2 message: %q\n", resp.Name)
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.Hl7V2Stores.Messages;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.Message;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessagePatch {
  private static final String MESSAGE_NAME =
      "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessagePatch(String hl7v2MessageName) throws IOException {
    // String hl7v2MessageName =
    //    String.format(
    //        MESSAGE_NAME, "project-id", "region-id", "dataset-id", "hl7v2-id", "message-id");

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

    // Fetch the initial state of the message.
    Messages.Get getRequest =
        client.projects().locations().datasets().hl7V2Stores().messages().get(hl7v2MessageName);
    Message message = getRequest.execute();

    // Update the Message fields as needed as needed. For a full list of Message fields, see:
    // https://cloud.google.com/healthcare/docs/reference/rest/v1/projects.locations.datasets.hl7V2Stores.messages
    Map<String, String> labels = new HashMap<>();
    labels.put("key1", "value1");
    labels.put("key2", "value2");
    message.setLabels(labels);

    // Create request and configure any parameters.
    Messages.Patch request =
        client
            .projects()
            .locations()
            .datasets()
            .hl7V2Stores()
            .messages()
            .patch(hl7v2MessageName, message)
            .setUpdateMask("labels");

    // Execute the request and process the results.
    message = request.execute();
    System.out.println("HL7v2 message patched: \n" + message.toPrettyString());
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const patchHl7v2Message = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  // const hl7v2MessageId = 'qCnewKno44gTt3oBn4dQ0u8ZA23ibDdV9GpifD2E=';
  // const labelKey = 'status';
  // const labelValue = 'processed';
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}/messages/${hl7v2MessageId}`;
  const request = {
    name,
    updateMask: 'labels',
    resource: {
      labels: {
        labelKey: labelValue,
      },
    },
  };

  await healthcare.projects.locations.datasets.hl7V2Stores.messages.patch(
    request
  );
  console.log('Patched HL7v2 message');
};

patchHl7v2Message();

Python

def patch_hl7v2_message(
    project_id,
    cloud_region,
    dataset_id,
    hl7v2_store_id,
    hl7v2_message_id,
    label_key,
    label_value,
):
    """Updates the message."""
    client = get_client()
    hl7v2_message_parent = "projects/{}/locations/{}".format(
        project_id, cloud_region
    )
    hl7v2_message_name = "{}/datasets/{}/hl7V2Stores/{}/messages/{}".format(
        hl7v2_message_parent, dataset_id, hl7v2_store_id, hl7v2_message_id
    )

    patch = {"labels": {label_key: label_value}}

    request = (
        client.projects()
        .locations()
        .datasets()
        .hl7V2Stores()
        .messages()
        .patch(name=hl7v2_message_name, updateMask="labels", body=patch)
    )

    response = request.execute()
    print(
        "Patched HL7v2 message {} with labels:\n\t{}: {}".format(
            hl7v2_message_id, label_key, label_value
        )
    )
    return response

Obtén el contenido de los mensajes de HL7v2

Los siguientes ejemplos muestran cómo obtener el contenido de un mensaje de HL7v2 con el método projects.locations.datasets.hl7V2Stores.messages.get. Para determinar las partes del mensaje que deseas obtener, proporciona el parámetro de consulta view con una de las siguientes opciones:

  • BASIC: Incluye solo el campo name.
  • RAW_ONLY: incluye todos los campos del mensaje, excepto el campo parsedData.
  • PARSED_ONLY: incluye todos los campos del mensaje, excepto el campo data.
  • FULL: Incluye todos los campos del mensaje. Esta es la opción predeterminada.

En los siguientes ejemplos, se muestra cómo obtener el contenido de un mensaje HL7v2 mediante las vistas FULL, RAW_ONLY y PARSED_ONLY.

Usa la vista FULL

No es necesario que configures explícitamente la vista FULL, ya que FULL es el valor predeterminado. Sin embargo, en las siguientes muestras de curl y Windows PowerShell, la vista FULL se agrega como un parámetro de consulta para su finalización.

curl

Para obtener el contenido de un mensaje HL7v2 mediante la vista FULL, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • FULL como la view
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl.

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/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=FULL"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ],
  "parsedData": {
    "segments": [
      {
        ""segmentId": "SEGMENT_ID_1",
        "fields": {
          FIELDS_1
        }
      },
      {
        "segmentId": "SEGMENT_ID_2",
        "fields": {
          FIELDS_2
        }
      },
      {
        "segmentId": "SEGMENT_ID_3",
        "fields": {
          FIELDS_3
        }
      }
    ]
  }
}

PowerShell

Para obtener el contenido de un mensaje HL7v2 mediante la vista FULL, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • FULL como la view
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=FULL" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ],
  "parsedData": {
    "segments": [
      {
        ""segmentId": "SEGMENT_ID_1",
        "fields": {
          FIELDS_1
        }
      },
      {
        "segmentId": "SEGMENT_ID_2",
        "fields": {
          FIELDS_2
        }
      },
      {
        "segmentId": "SEGMENT_ID_3",
        "fields": {
          FIELDS_3
        }
      }
    ]
  }
}

Go

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// getHL7V2Message gets an HL7V2 message.
func getHL7V2Message(w io.Writer, projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s", projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID)
	message, err := messagesService.Get(name).Do()
	if err != nil {
		return fmt.Errorf("Get: %v", err)
	}

	rawData, err := base64.StdEncoding.DecodeString(message.Data)
	if err != nil {
		return fmt.Errorf("base64.DecodeString: %v", err)
	}

	fmt.Fprintf(w, "Got HL7V2 message.\n")
	fmt.Fprintf(w, "Raw length: %d.\n", len(rawData))
	fmt.Fprintf(w, "Parsed data:\n")
	parsedJSON, _ := json.MarshalIndent(message.ParsedData, "", "  ")
	fmt.Fprintf(w, "%s", parsedJSON)
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.Hl7V2Stores.Messages;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.Message;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessageGet {
  private static final String MESSAGE_NAME =
      "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessageGet(String hl7v2MessageName) throws IOException {
    // String hl7v2MessageName =
    //    String.format(
    //        MESSAGE_NAME, "project-id", "region-id", "dataset-id", "hl7v2-id", "message-id");

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

    // Create request and configure any parameters.
    Messages.Get request =
        client.projects().locations().datasets().hl7V2Stores().messages().get(hl7v2MessageName);

    // Execute the request and process the results.
    Message store = request.execute();
    System.out.println("HL7v2 message retrieved: \n" + store.toPrettyString());
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const getHl7v2Message = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  // const hl7v2MessageId = 'qCnewKno44gTt3oBn4dQ0u8ZA23ibDdV9GpifD2E=';
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}/messages/${hl7v2MessageId}`;
  const view = 'FULL';
  const request = {name, view};

  const hl7v2Message = await healthcare.projects.locations.datasets.hl7V2Stores.messages.get(
    request
  );
  console.log('Got HL7v2 message:\n', hl7v2Message.data);
};

getHl7v2Message();

Python

def get_hl7v2_message(
    project_id, cloud_region, dataset_id, hl7v2_store_id, hl7v2_message_id
):
    """Gets an HL7v2 message."""
    client = get_client()
    hl7v2_parent = "projects/{}/locations/{}".format(project_id, cloud_region)
    hl7v2_message_name = "{}/datasets/{}/hl7V2Stores/{}/messages/{}".format(
        hl7v2_parent, dataset_id, hl7v2_store_id, hl7v2_message_id
    )

    msgs = client.projects().locations().datasets().hl7V2Stores().messages()
    message = msgs.get(name=hl7v2_message_name).execute()

    print("Name: {}".format(message.get("name")))
    print("Data: {}".format(message.get("data")))
    print("Creation time: {}".format(message.get("createTime")))
    print("Sending facility: {}".format(message.get("sendFacility")))
    print("Time sent: {}".format(message.get("sendTime")))
    print("Message type: {}".format(message.get("messageType")))
    print("Patient IDs:")
    patient_ids = message.get("patientIds")
    for patient_id in patient_ids:
        print("\tPatient value: {}".format(patient_id.get("value")))
        print("\tPatient type: {}".format(patient_id.get("type")))
    print("Labels: {}".format(message.get("labels")))

    print(message)
    return message

Usa la vista RAW_ONLY

En los siguientes ejemplos, se muestra cómo obtener el contenido de un mensaje HL7v2 mediante la vista RAW_ONLY, que incluye todos los campos del mensaje, excepto parsedData.

curl

Para obtener el contenido de un mensaje HL7v2 mediante la vista RAW_ONLY, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • RAW_ONLY como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl.

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/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=RAW_ONLY"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ]
}

PowerShell

Para obtener el contenido de un mensaje HL7v2 mediante la vista RAW_ONLY, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • RAW_ONLY como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=RAW_ONLY" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "data": "DATA",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ]
}

Usa la vista PARSED_ONLY

En los siguientes ejemplos, se muestra cómo obtener el contenido de un mensaje HL7v2 mediante la vista PARSED_ONLY, que incluye todos los campos del mensaje, excepto data.

curl

Para obtener el contenido de un mensaje HL7v2 mediante la vista PARSED_ONLY, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • PARSED_ONLY como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl.

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/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=PARSED_ONLY"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ],
  "parsedData": {
    "segments": [
      {
        "segmentId": "SEGMENT_ID_1",
        "fields": {
          FIELDS_1
        }
      },
      {
        "segmentId": "SEGMENT_ID_2",
        "fields": {
          FIELDS_2
        }
      },
      {
        "segmentId": "SEGMENT_ID_3",
        "fields": {
          FIELDS_3
        }
      }
    ]
  }
}

PowerShell

Para obtener el contenido de un mensaje HL7v2 mediante la vista PARSED_ONLY, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • PARSED_ONLY como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=PARSED_ONLY" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
  "sendFacility": "SEND_FACILITY",
  "sendTime": "2018-01-01T00:00:00Z",
  "messageType": "TYPE",
  "createTime": "CREATE_TIME",
  "patientIds": [
    {
        "value": "VALUE_1",
        "type": "TYPE_1"
    },
    {
        "value": "VALUE_2",
        "type": "TYPE_2"
    },
    {
        "value": "VALUE_3",
        "type": "TYPE_3"
    }
  ],
  "parsedData": {
    "segments": [
      {
        "segmentId": "SEGMENT_ID_1",
        "fields": {
          FIELDS_1
        }
      },
      {
        "segmentId": "SEGMENT_ID_2",
        "fields": {
          FIELDS_2
        }
      },
      {
        "segmentId": "SEGMENT_ID_3",
        "fields": {
          FIELDS_3
        }
      }
    ]
  }
}

Usa la vista BASIC

En los siguientes ejemplos, se muestra cómo obtener el contenido de un mensaje HL7v2 mediante la vista BASIC, que incluye solo el campo name.

curl

Para obtener el contenido de un mensaje HL7v2 mediante la vista BASIC, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • BASIC como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl.

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/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=BASIC"

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
}

PowerShell

Para obtener el contenido de un mensaje HL7v2 mediante la vista BASIC, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje
  • BASIC como la vista
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID?view=BASIC" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"
}

Enumera mensajes de HL7v2

En los siguientes ejemplos, se muestra cómo enumerar los mensajes en un almacén de HL7v2 con el método. Para determinar la información sobre cada mensaje que se incluirá en la lista, especifica el parámetro de consulta view con una de las siguientes opciones:

  • BASIC: Incluye solo el campo name. Esta es la opción predeterminada.
  • RAW_ONLY: incluye todos los campos del mensaje, excepto el campo parsedData.
  • PARSED_ONLY: incluye todos los campos del mensaje, excepto el campo data.
  • FULL: Incluye todos los campos del mensaje.

curl

Para enumerar los mensajes en una tienda HL7v2, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El view, uno de BASIC, RAW_ONLY, PARSED_ONLY o FULL o se omite para usar el valor predeterminado de BASIC
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante curl. La solicitud especifica ?view=FULL para incluir todos los campos del mensaje.

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/hl7V2Stores/HL7V2_STORE_ID/messages?view=FULL"

Si la solicitud es exitosa, el servidor muestra un código de estado HTTP 200 OK y un arreglo de mensajes llamado hl7_v2_messages. La siguiente respuesta de muestra está truncada.

{
  "hl7_v2_messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
      "data": "DATA",
      "sendFacility": "SEND_FACILITY",
      "sendTime": "SEND_TIME",
      "messageType": "MESSAGE_TYPE",
      "createTime": "CREATE_TIME",
      ...
    },
    ...
  ]
}

PowerShell

Para enumerar los mensajes en una tienda HL7v2, realiza una solicitud GET y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El view, uno de BASIC, RAW_ONLY, PARSED_ONLY o FULL o se omite para usar el valor predeterminado de BASIC
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud GET mediante Windows PowerShell. La solicitud especifica ?view=FULL para incluir todos los campos del mensaje.

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

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages?view=FULL" | Select-Object -Expand Content

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor. La respuesta de muestra está truncada.

{
  "hl7_v2_messages": [
    {
      "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID",
      "data": "DATA",
      "sendFacility": "SEND_FACILITY",
      "sendTime": "SEND_TIME",
      "messageType": "MESSAGE_TYPE",
      "createTime": "CREATE_TIME",
      ...
    },
    ...
  ]
}

Go

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// listHL7V2Messages prints a list of HL7V2 messages to w.
func listHL7V2Messages(w io.Writer, projectID, location, datasetID, hl7V2StoreID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	parent := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s", projectID, location, datasetID, hl7V2StoreID)

	resp, err := messagesService.List(parent).Do()
	if err != nil {
		return fmt.Errorf("List: %v", err)
	}

	fmt.Fprintln(w, "HL7V2 messages:")
	for _, s := range resp.Hl7V2Messages {
		fmt.Fprintln(w, s.Name)
	}
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.ListMessagesResponse;
import com.google.api.services.healthcare.v1.model.Message;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessageList {
  private static final String HL7v2_NAME = "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessageList(String hl7v2StoreName) throws IOException {
    // String hl7v2StoreName =
    //    String.format(
    //        HL7v2_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-hl7v2-id");

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

    // Results are paginated, so multiple queries may be required.
    String pageToken = null;

    do {
      // Create request and execute.
      ListMessagesResponse messageResponse =
          client
              .projects()
              .locations()
              .datasets()
              .hl7V2Stores()
              .messages()
              .list(hl7v2StoreName)
              .setPageSize(100)
              .setPageToken(pageToken)
              .execute();

      if (messageResponse.getHl7V2Messages() != null) {
        // Print results.
        System.out.printf(
            "Retrieved %s HL7v2 messages: \n", messageResponse.getHl7V2Messages().size());
        for (Message message : messageResponse.getHl7V2Messages()) {
          System.out.println(message);
        }
      }
      // Update the page token for the next request.
      pageToken = messageResponse.getNextPageToken();
    } while (pageToken != null);
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const listHl7v2Messages = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  const parent = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}`;
  const request = {parent};

  const response = await healthcare.projects.locations.datasets.hl7V2Stores.messages.list(
    request
  );
  const hl7v2Messages = response.data.hl7V2Messages;
  console.log(`HL7v2 messages: ${hl7v2Messages.length}`);
  for (const hl7v2Message of hl7v2Messages) {
    console.log(hl7v2Message);
  }
};

listHl7v2Messages();

Python

def list_hl7v2_messages(project_id, cloud_region, dataset_id, hl7v2_store_id):
    """Lists all the messages in the given HL7v2 store with support for
    filtering.
    """
    client = get_client()
    hl7v2_messages_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, cloud_region, dataset_id
    )
    hl7v2_message_path = "{}/hl7V2Stores/{}".format(
        hl7v2_messages_parent, hl7v2_store_id
    )

    hl7v2_messages = (
        client.projects()
        .locations()
        .datasets()
        .hl7V2Stores()
        .messages()
        .list(parent=hl7v2_message_path)
        .execute()
        .get("hl7V2Messages", [])
    )

    for hl7v2_message in hl7v2_messages:
        print(hl7v2_message)

    return hl7v2_messages

Borra un mensaje de HL7v2

En las siguientes muestras, se muestra cómo borrar un mensaje de HL7v2 con el método projects.locations.datasets.hl7V2Stores.messages.delete.

curl

Para borrar un mensaje de HL7v2, realiza una solicitud DELETE y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje de HL7v2
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud DELETE mediante curl.

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID"

Si la solicitud es exitosa, el servidor muestra la respuesta de cuerpo vacío en formato JSON:

{}

PowerShell

Para borrar un mensaje de HL7v2, realiza una solicitud DELETE y especifica la siguiente información:

  • El nombre del conjunto de datos superior
  • El nombre del almacén de HL7v2
  • El ID del mensaje de HL7v2
  • Un token de acceso

En el siguiente ejemplo, se muestra una solicitud DELETE mediante Windows PowerShell.

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

Invoke-WebRequest `
  -Method Delete `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/hl7V2Stores/HL7V2_STORE_ID/messages/MESSAGE_ID" | Select-Object -Expand Content

Si la solicitud se realiza con éxito, el servidor muestra el cuerpo de la respuesta vacío en formato JSON:

{}

Go

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// deleteHL7V2Message deletes an HL7V2 message.
func deleteHL7V2Message(w io.Writer, projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %v", err)
	}

	messagesService := healthcareService.Projects.Locations.Datasets.Hl7V2Stores.Messages

	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s", projectID, location, datasetID, hl7V2StoreID, hl7V2MessageID)
	if _, err := messagesService.Delete(name).Do(); err != nil {
		return fmt.Errorf("Delete: %v", err)
	}

	fmt.Fprintf(w, "Deleted HL7V2 message: %q\n", name)
	return nil
}

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.jackson2.JacksonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.Hl7V2Stores.Messages;
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.util.Collections;

@SuppressWarnings("checkstyle:AbbreviationAsWordInName")
public class HL7v2MessageDelete {
  private static final String MESSAGE_NAME =
      "projects/%s/locations/%s/datasets/%s/hl7V2Stores/%s/messages/%s";
  private static final JsonFactory JSON_FACTORY = new JacksonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void hl7v2MessageDelete(String hl7v2MessageName) throws IOException {
    // String hl7v2MessageName =
    //    String.format(
    //        MESSAGE_NAME, "project-id", "region-id", "dataset-id", "hl7v2-id", "message-id");

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

    // Create request and configure any parameters.
    Messages.Delete request =
        client.projects().locations().datasets().hl7V2Stores().messages().delete(hl7v2MessageName);

    // Execute the request and process the results.
    request.execute();
    System.out.println("HL7v2 message deleted.");
  }

  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();
  }
}

Node.js

const {google} = require('googleapis');
const healthcare = google.healthcare('v1');

const deleteHl7v2Message = async () => {
  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  });
  google.options({auth});

  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const hl7v2StoreId = 'my-hl7v2-store';
  // const hl7v2MessageId = 'qCnewKno44gTt3oBn4dQ0u8ZA23ibDdV9GpifD2E=';
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/hl7V2Stores/${hl7v2StoreId}/messages/${hl7v2MessageId}`;
  const request = {name};

  await healthcare.projects.locations.datasets.hl7V2Stores.messages.delete(
    request
  );
  console.log('Deleted HL7v2 message');
};

deleteHl7v2Message();

Python

def delete_hl7v2_message(
    project_id, cloud_region, dataset_id, hl7v2_store_id, hl7v2_message_id
):
    """Deletes an HL7v2 message."""
    client = get_client()
    hl7v2_parent = "projects/{}/locations/{}".format(project_id, cloud_region)
    hl7v2_message = "{}/datasets/{}/hl7V2Stores/{}/messages/{}".format(
        hl7v2_parent, dataset_id, hl7v2_store_id, hl7v2_message_id
    )

    request = (
        client.projects()
        .locations()
        .datasets()
        .hl7V2Stores()
        .messages()
        .delete(name=hl7v2_message)
    )

    response = request.execute()
    print("Deleted HL7v2 message with ID: {}".format(hl7v2_message_id))
    return response

¿Qué sigue?