Exemplos em TypeScript
Esta documentação apresenta exemplos de código escritos em TypeScript, utilizados para integrar-se à API da WaveLight. Embora a WaveLight utilize o framework React.js para desenvolvimento frontend, os exemplos fornecidos podem ser facilmente adaptados para qualquer framework ou biblioteca JavaScript, como Vue.js, Angular, ou até mesmo aplicações JavaScript puras (Vanilla JS).
Nosso objetivo é facilitar a implementação da API em diferentes ambientes, garantindo flexibilidade para os desenvolvedores. Caso prefira usar JavaScript puro, basta remover as tipagens TypeScript para compatibilidade total.
A documentação a seguir guiará você na utilização dos principais recursos da API, incluindo upload de arquivos, escuta de eventos em tempo real (SSE) e envio de requisições assíncronas.
Solicitação de Serviço - Exemplo de Uso
Este exemplo de código demonstra como criar uma solicitação de serviço para a API da Wavelight Health. Ele inclui a definição de enums, interfaces e uma função assíncrona para envio de dados do paciente e seleção de serviços.
1. Enum de Serviços Disponíveis
export enum Service {
HEART_BEATS = "HEART BEATS",
BLOOD_PRESSURE = "BLOOD PRESSURE",
OXIMETRY = "OXIMETRY",
}
2. Enum e Interface para Dados do Paciente
export enum Gender {
UNDEFINED = "UNDEFINED",
MALE = "MALE",
FEMALE = "FEMALE",
}
export interface WorkflowPerson {
height: number;
weight: number;
age: number;
gender: Gender;
}
3. Interfaces para Respostas da API
A resposta da API contém informações como ID da requisição, URL para upload de vídeo e dados estruturados sobre o paciente e estudo.
export interface ServiceRequestResponse {
requestId: string;
uploadVideoUrl: string;
wpgContent: WpgContent;
}
export interface WpgContent {
header: Header;
study: Study;
patient: Patient;
}
export interface Header {
"content-type": string;
version: string;
hash: string;
secure: boolean;
}
export interface Study {
UUID: string;
created: string;
source: Source;
}
export interface Source {
device: Device;
institution: string;
application: string;
captured_by: CapturedBy;
}
export interface Device {
model: string;
features: string[];
}
export interface CapturedBy {
user_type: string;
professional_name: string;
professional_id: string;
}
export interface Patient {
anonymous: AnonymousField[];
}
export interface AnonymousField {
label: "age" | "sex" | "height" | "weight" | string;
unit: "years" | "enum" | "cm" | "kg" | string;
value: number | string;
}
4. Função para Criar uma Solicitação de Serviço
export const createServiceRequestRequest = async (
selectedServices: Service[],
person: WorkflowPerson
): Promise<ServiceRequestResponse> => {
const apiKey = ProcessingInstruction.env.API_KEY;
const payload = {
serviceList: selectedServices,
WPG_Object: {
header: {
"content-type": "",
version: "",
hash: "",
secure: true,
},
study: {
created: new Date(),
source: {
device: {
model: "",
features: [],
},
institution: "",
application: "",
captured_by: {
user_type: "",
professional_name: "",
professional_id: "",
},
},
},
patient: {
anonymous: [
{ label: "age", unit: "years", value: person.age },
{ label: "sex", unit: "enum", value: person.gender },
{ label: "height", unit: "cm", value: person.height },
{ label: "weight", unit: "kg", value: person.weight },
],
},
},
};
const response = await axios.post<ServiceRequestResponse>(
"https://api.wavelighthealth.com/api",
payload,
{
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
validateStatus: () => true,
}
);
return response.data;
};
5. Como Usar
const personData: WorkflowPerson = {
height: 175,
weight: 70,
age: 30,
gender: Gender.MALE,
};
const selectedServices = [Service.HEART_BEATS, Service.BLOOD_PRESSURE];
createServiceRequestRequest(selectedServices, personData)
.then(response => console.log("Service Request Created:", response))
.catch(error => console.error("Error:", error));
Função uploadFileOn - Exemplo de Uso
A função uploadFileOn é usada para enviar arquivos binários (como vídeos) para um endpoint de upload fornecido via URL pré-assinada. Este método é comumente usado para transferência eficiente de arquivos para um servidor sem passar pelo backend do desenvolvedor.
Parâmetros
-
presigned: ServiceRequestResponse - Um objeto contendo a URL pré-assinada (uploadVideoUrl) onde o arquivo será enviado.
-
fileBlob: File - O arquivo a ser enviado, representado como um objeto File.
Implementação
export const uploadFileOn = async (
presigned: ServiceRequestResponse,
fileBlob: File
) => {
const response = await axios.put(presigned.uploadVideoUrl, fileBlob, {
headers: {
"Content-Type": "application/octet-stream", // Ensures correct binary file upload
},
});
return response.data;
};
Como usar
Para usar esta função, siga estes passos:
Passo 1: Obter a URL Pré-assinada
Antes de chamar uploadFileOn , você precisa obter a URL pré-assinada da API do serviço.
const serviceResponse = await createServiceRequestRequest(selectedServices, person);
Passo 2: Selecionar o Arquivo para Upload
O arquivo pode ser obtido, por exemplo, de um input HTML.
const fileInput = document.querySelector("input[type='file']") as HTMLInputElement;
const file = fileInput.files?.[0];
Passo 3: Enviar o Arquivo
Com a URL pré-assinada e o arquivo selecionado, chame uploadFileOn
if (file) {
await uploadFileOn(serviceResponse, file);
console.log("Upload successful!");
} else {
console.error("No file selected.");
}
Considerações
-
Certifique-se de que a URL pré-assinada ainda é válida antes de fazer o upload..
-
O Content-Type é definido como application/octet-stream para garantir compatibilidade com diferentes tipos de arquivos binários.
-
Esta abordagem reduz a carga no backend do desenvolvedor, pois os arquivos são enviados diretamente para o servidor de armazenamento.
Conclusão
A função uploadFileOn fornece uma solução simples e eficaz para o upload de arquivos usando URLs pré-assinadas, garantindo segurança e eficiência na transmissão de dados.
Função listenToServiceResults
A função listenToServiceResults escuta eventos enviados pelo servidor (SSE) relacionados a uma solicitação de serviço. Isso permite atualizações em tempo real sobre o processamento de uma solicitação feita à API.
Parâmetros
A função requestId: ServiceRequestResponse escuta eventos enviados pelo servidor (SSE) relacionados a uma solicitação de serviço. Isso permite atualizações em tempo real sobre o processamento de uma solicitação feita à API.
-
requestId: ServiceRequestResponse - Um objeto contendo o identificador único da solicitação ( requestId ).
-
selectedServices: Service[] - Lista de serviços selecionados na solicitação.
-
onResults: (parsedResults: any[]) => void - Função de callback chamada sempre que novos resultados são recebidos.
Implementação
import { EventSourcePolyfill } from "event-source-polyfill";
export const listenToServiceResults = (
requestId: ServiceRequestResponse,
selectedServices: Service[],
onResults: (parsedResults: any[]) => void
) => {
const apiKey = process.env.API_KEY;
const sse = new EventSourcePolyfill(
`https://api.wavelighthealth.com/gateway/sse-request-track/${requestId.requestId}`,
{
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${apiKey}`,
},
}
);
sse.onmessage = (event) => {
try {
const eventData: EventData = JSON.parse(event.data);
if (eventData.results?.length > 0) {
const parsedResults = eventData.results.map((result) => ({
...result,
return: JSON.parse(result.return),
}));
onResults(parsedResults);
const allServicesReturned = selectedServices.every((service) =>
parsedResults.find((result) => result.name === service)
);
if (allServicesReturned) {
sse.close();
}
}
} catch (error) {
console.error("[SSE] Failed to process message:", error);
}
};
return sse; // Returns the SSE instance in case manual control is needed
};
Como Usar
Para usar esta função, siga os seguintes passos:
Passo 1: Começar a Escutar Eventos
Após criar uma solicitação de serviço, use a função para começar a escutar eventos.
const sse = listenToServiceResults(serviceResponse, selectedServices, (results) => {
console.log("New results received:", results);
});
Passo 2: Controlar a Instância SSE (Opcional)
Se for necessário desconectar manualmente, use:
sse.close();
Considerações
-
Esta abordagem permite atualizações em tempo real sem a necessidade de polling contínuo.
-
Se todos os serviços retornarem um resultado, a conexão será fechada automaticamente.
-
Garanta um tratamento de erros adequado para evitar falhas na execução
Conclusion
A função listenToServiceResults fornece uma solução eficiente para acompanhar eventos do servidor em tempo real, garantindo uma comunicação assíncrona otimizada entre o cliente e o serviço.
Esta documentação serve como um guia rápido para integração com a API Wavelight Health. Para mais informações, consulte a documentação oficial.