fullsnackerHL7, conocido también como Health Level 7, es un estándar de mensajería y normas clínicas utilizado para la integración, intercambio, gestión y recuperación de información electrónica en distintos sistemas de salud. Es un protocolo basado en transacciones que se activan por eventos, como la admisión de un paciente en un hospital. HL7 facilita el intercambio de información en el ámbito de la salud pública.
Se trata de un estándar ampliamente aceptado a nivel internacional para el intercambio de datos en el sector de la salud, siendo independiente de la plataforma y tecnología utilizada.
¿Por qué utilizar HL7?
Los sistemas de atención médica suelen emplear diferentes aplicaciones, desarrolladas en distintos lenguajes de programación y con funcionalidades variadas. Por ejemplo, los hospitales suelen tener sistemas complejos y personalizados, mientras que los médicos generales suelen utilizar software de gestión de consultas ya listo para su uso. Los institutos de investigación médica, por su parte, pueden utilizar software que forma parte de una red más amplia, como la de una universidad. En muchas ocasiones, estas instituciones necesitan intercambiar datos sobre los pacientes.
El propósito de HL7 es permitir a las organizaciones de salud generar datos uniformes, accesibles para cualquier persona autorizada, independientemente del sistema que utilicen. La interoperabilidad entre organizaciones sanitarias requiere que las interfaces de los distintos sistemas utilicen un protocolo común como HL7.
¿Quién utiliza HL7?
- Hospitales
- Centros de imagen médica
- Doctores
- Clínicas gubernamentales
- Laboratorios
- Residencias
- Farmacias, entre otros
Tipos de Mensajes HL7
- ACK — Reconocimiento general
- ADT — Admisión, alta y transferencia de pacientes
- BAR — Creación/cambio de cuenta de facturación
- DFT — Transacción financiera detallada
- MDM — Gestión de documentos médicos
- MFN — Notificación de archivos maestros
- ORM — Orden (Farmacia/tratamiento)
- ORU — Resultado de observación (no solicitado)
- QRY — Consulta, modo original
- RAS — Administración de farmacia/tratamiento
- RDE — Orden codificada de farmacia/tratamiento
- RGV — Administración de farmacia/tratamiento
- SIU — Información de programación no solicitada
Mensajes ADT más comunes:
- ADT-A01: Ingreso del paciente.
- ADT-A02: Transferencia del paciente.
- ADT-A03: Alta del paciente.
- ADT-A04: Registro del paciente.
- ADT-A05: Preingreso del paciente.
- ADT-A08: Actualización de la información del paciente.
- ADT-A11: Cancelación de la admisión del paciente.
- ADT-A12: Cancelación de la transferencia del paciente.
¿Cómo se transmiten los mensajes HL7?
Generalmente, los mensajes HL7 se transmiten mediante el protocolo TCP/IP a través de una red local, como dentro de la red de un hospital. Los datos TCP/IP se envían como un flujo de bytes, lo que permite el envío de múltiples mensajes en un flujo continuo. Esto puede generar confusión, por lo que es necesario definir claramente el punto de inicio y final de cada mensaje. Para esto, se utiliza el Protocolo Mínimo de Capa Inferior (MLP), que añade un encabezado y un pie de página a cada mensaje.
El Protocolo Mínimo de Capa Inferior (MLP) se refiere a un protocolo básico que opera en las capas inferiores de la pila de red, como la capa física o de enlace de datos. Proporciona las funciones fundamentales necesarias para la comunicación entre dispositivos de red, especificando cómo envolver un mensaje HL7 con un encabezado y un pie de página para garantizar que se identifique correctamente el inicio y fin de cada mensaje, así como el comienzo del siguiente.
Ejemplo básico de un programa en Java que toma un mensaje HL7, lo guarda en un objeto y luego imprime sus detalles en la consola:
public class HL7Message {
private String message;
public HL7Message(String message) {
this.message = message;
}
public String getMessageType() {
return message.split("\\|")[8];
}
public String getPatientID() {
return message.split("\\|")[3];
}
public String getPatientName() {
return message.split("\\|")[5];
}
public void printDetails() {
System.out.println("HL7 Message Details:");
System.out.println("Message Type: " + getMessageType());
System.out.println("Patient ID: " + getPatientID());
System.out.println("Patient Name: " + getPatientName());
}
public static void main(String[] args) {
String hl7Message = "MSH|^~\\&|HIS|RIH|EKG|EKG|202308120830||ADT^A01|MSG00001|P|2.5|"
+ "PID|1||123456||DOE^JOHN^A||19680219|M|||123 MAIN ST^^ANYTOWN^OH^12345|(555)555-1234|||M|NON|||123-45-6789";
HL7Message message = new HL7Message(hl7Message);
message.printDetails();
}
}
Explicación:
HL7Message Class: Esta clase contiene el mensaje HL7 y proporciona métodos para extraer y mostrar algunos detalles básicos como el tipo de mensaje, el ID del paciente, y el nombre del paciente.
getMessageType: Este método extrae el tipo de mensaje del HL7 (campo 9).
getPatientID: Este método extrae el ID del paciente (campo 4).
getPatientName: Este método extrae el nombre del paciente (campo 6).
printDetails: Este método imprime los detalles del mensaje HL7.
main: En el método main, se define un mensaje HL7 de ejemplo, se crea un objeto HL7Message con el mensaje, y se imprimen los detalles.
Este programa es básico y solo maneja un mensaje HL7 muy simple. Dependiendo de los requerimientos, podrías necesitar una implementación más avanzada para manejar la estructura completa de los mensajes HL7.
Programa básico en Java que genera un mensaje HL7 a partir de un objeto HL7Message que se llena previamente:
public class HL7Message {
private String sendingApplication;
private String sendingFacility;
private String receivingApplication;
private String receivingFacility;
private String messageDateTime;
private String messageType;
private String messageControlID;
private String processingID;
private String versionID;
private String patientID;
private String patientLastName;
private String patientFirstName;
private String patientDOB;
private String patientGender;
private String patientAddress;
private String patientPhoneNumber;
private String patientSSN;
// Constructor
public HL7Message(String sendingApplication, String sendingFacility, String receivingApplication,
String receivingFacility, String messageDateTime, String messageType,
String messageControlID, String processingID, String versionID, String patientID,
String patientLastName, String patientFirstName, String patientDOB, String patientGender,
String patientAddress, String patientPhoneNumber, String patientSSN) {
this.sendingApplication = sendingApplication;
this.sendingFacility = sendingFacility;
this.receivingApplication = receivingApplication;
this.receivingFacility = receivingFacility;
this.messageDateTime = messageDateTime;
this.messageType = messageType;
this.messageControlID = messageControlID;
this.processingID = processingID;
this.versionID = versionID;
this.patientID = patientID;
this.patientLastName = patientLastName;
this.patientFirstName = patientFirstName;
this.patientDOB = patientDOB;
this.patientGender = patientGender;
this.patientAddress = patientAddress;
this.patientPhoneNumber = patientPhoneNumber;
this.patientSSN = patientSSN;
}
// Método para generar el mensaje HL7
public String generateHL7Message() {
StringBuilder hl7Message = new StringBuilder();
// MSH Segment
hl7Message.append("MSH|^~\\&|")
.append(sendingApplication).append("|")
.append(sendingFacility).append("|")
.append(receivingApplication).append("|")
.append(receivingFacility).append("|")
.append(messageDateTime).append("||")
.append(messageType).append("|")
.append(messageControlID).append("|")
.append(processingID).append("|")
.append(versionID).append("\r");
// PID Segment
hl7Message.append("PID|1||")
.append(patientID).append("||")
.append(patientLastName).append("^")
.append(patientFirstName).append("||")
.append(patientDOB).append("|")
.append(patientGender).append("|||")
.append(patientAddress).append("|")
.append(patientPhoneNumber).append("|||||||")
.append(patientSSN).append("\r");
return hl7Message.toString();
}
public static void main(String[] args) {
// Llenar los datos del objeto HL7Message
HL7Message message = new HL7Message(
"HIS", // sendingApplication
"RIH", // sendingFacility
"EKG", // receivingApplication
"EKG", // receivingFacility
"202308120830", // messageDateTime
"ADT^A01", // messageType
"MSG00001", // messageControlID
"P", // processingID
"2.5", // versionID
"123456", // patientID
"DOE", // patientLastName
"JOHN", // patientFirstName
"19680219", // patientDOB
"M", // patientGender
"123 MAIN ST^^ANYTOWN^OH^12345", // patientAddress
"(555)555-1234", // patientPhoneNumber
"123-45-6789" // patientSSN
);
// Generar y mostrar el mensaje HL7
String hl7Message = message.generateHL7Message();
System.out.println("Generated HL7 Message:\n" + hl7Message);
}
}
Explicación:
HL7Message Class: Esta clase contiene los campos necesarios para un mensaje HL7 simple, incluyendo información sobre la aplicación que envía, la aplicación que recibe, y detalles del paciente.
generateHL7Message: Este método construye el mensaje HL7 usando los campos proporcionados y los formatea en un formato estándar HL7. Aquí se están generando dos segmentos: MSH (encabezado del mensaje)
