HL7, também conhecido como Health Level 7, é um padrão de mensagens e padrões clínicos usado para integração, troca, gerenciamento e recuperação de informações eletrônicas em diferentes sistemas de saúde. É um protocolo baseado em transações acionadas por eventos, como a internação de um paciente em um hospital. O HL7 facilita a troca de informações na área de saúde pública.

Este é um padrão internacional amplamente aceito para troca de dados no setor de saúde, sendo independente da plataforma e da tecnologia utilizada.

Por que usar o HL7?

Os sistemas de saúde costumam utilizar diferentes aplicações, desenvolvidas em diferentes linguagens de programação e com funcionalidades variadas. Por exemplo, os hospitais costumam ter sistemas complexos e personalizados, enquanto os médicos de clínica geral costumam usar software de gerenciamento de consultórios prontos para uso. Os institutos de pesquisa médica, por sua vez, podem utilizar software que faça parte de uma rede maior, como a de uma universidade. Em muitas ocasiões, essas instituições precisam trocar dados sobre os pacientes.

O objetivo do HL7 é permitir que as organizações de saúde gerem dados consistentes, acessíveis a qualquer pessoa autorizada, independentemente do sistema que utilizam. A interoperabilidade entre organizações de saúde exige que as interfaces dos diferentes sistemas utilizem um protocolo comum como o HL7.

Quem usa HL7?

• Hospitais
• Centros de imagens médicas
• Médicos
• Clínicas governamentais
• Laboratórios
• Residências
• Farmácias, entre outros

Tipos de mensagens HL7

• ACK — Agradecimento geral
• ADT — Admissão, alta e transferência do paciente
• BAR — Criação/alteração de conta de faturamento
• DFT — Transação financeira detalhada
• MDM — Gerenciamento de documentos médicos
• MFN — Notificação de arquivo mestre
• ORM — Pedido (Farmácia/tratamento)
• ORU — Resultado da observação (não solicitado)
• QRY — Consulta, modo original
• RAS — Farmácia/administração de tratamento
• RDE — Pedido codificado de farmácia/tratamento
• RGV — Farmácia/administração de tratamento
• SIU — Informações de agendamento não solicitadas

Mensagens ADT mais comuns:

• ADT-A01: Admissão do paciente.
• ADT-A02: Transferência de paciente.
• ADT-A03: Alta do paciente.
• ADT-A04: Registro do paciente.
• ADT-A05: Pré-admissão do paciente.
• ADT-A08: Atualizar informações do paciente.
• ADT-A11: Cancelamento da internação do paciente.
• ADT-A12: Cancelamento de transferência de paciente.

Como as mensagens HL7 são transmitidas?

Geralmente, as mensagens HL7 são transmitidas usando o protocolo TCP/IP em uma rede local, como em uma rede hospitalar. Os dados TCP/IP são enviados como um fluxo de bytes, permitindo que múltiplas mensagens sejam enviadas em um fluxo contínuo. Isso pode causar confusão, por isso é necessário definir claramente o ponto inicial e final de cada mensagem. Para isso, utiliza-se o protocolo MLP (Minimum Lower Layer Protocol), que adiciona um cabeçalho e um rodapé a cada mensagem.

Minimum Lower Layer Protocol (MLP) refere-se a um protocolo básico que opera nas camadas inferiores da pilha de rede, como a camada física ou de enlace de dados. Fornece as funções fundamentais necessárias para a comunicação entre dispositivos de rede, especificando como agrupar uma mensagem HL7 com cabeçalho e rodapé para garantir que o início e o fim de cada mensagem, bem como o início da próxima, sejam identificados corretamente.

Exemplo básico de um programa Java que recebe uma mensagem HL7, salva-a em um objeto e depois imprime seus detalhes no console:

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

Explicação:

Classe HL7Message: esta classe contém a mensagem HL7 e fornece métodos para extrair e exibir alguns detalhes básicos, como tipo de mensagem, ID do paciente e nome do paciente.

getMessageType: Este método extrai o tipo de mensagem do HL7 (campo 9).

getPatientID: Este método extrai o ID do paciente (campo 4).

getPatientName: Este método extrai o nome do paciente (campo 6).

printDetails: Este método imprime os detalhes da mensagem HL7.

main: No método main, você define uma mensagem HL7 de amostra, cria um objeto HL7Message com a mensagem e imprime os detalhes.

Este programa é básico e lida apenas com uma mensagem HL7 muito simples. Dependendo dos requisitos, você pode precisar de uma implementação mais avançada para lidar com toda a estrutura das mensagens HL7.

Programa Java básico que gera uma mensagem HL7 a partir de um objeto HL7Message pré-preenchido:

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

Explicação:

Classe HL7Message: Esta classe contém os campos necessários para uma mensagem HL7 simples, incluindo informações sobre o aplicativo de envio, o aplicativo de recebimento e detalhes do paciente.

generateHL7Message: Este método constrói a mensagem HL7 usando os campos fornecidos e os formata em um formato HL7 padrão. Dois segmentos estão sendo gerados aqui: MSH (cabeçalho da mensagem)