Buscar Etiquetas do Pedido

// Label.tsx
async function getLabel() {
  setIsLoading(true);
  socket?.emit(
    'get.label',
    { orderId: order.id },
    (response: LabelResponseWs) => {
      // Valida se a resposta corresponde ao pedido correto
      if (response.orderId !== order.id) return;
      
      // Atualiza estado com as etiquetas
      setLabels(response.data);
      setIsLoading(false);
      
      // Exibe erros se houver
      if (response.errors?.length > 0) {
        addNotification({
          title: 'Atenção!!!',
          message: response.errors
            ?.map((error) => error.description)
            .join('|'),
          bg: 'danger',
          className: 'text-white',
          autohide: true,
        });
      }
    }
  );
}

@SubscribeMessage('get.label')
async handleGetLabel(
  @ConnectedSocket() client: Socket,
  @MessageBody() data: { orderId: number },
) {
  try {
    // Emite evento interno e aguarda resposta (retorna array de promessas)
    const promises: {
      data: Record<string, any>[];
      errors: Error[];
    }[] = await this.eventEmitter.emitAsync(
      'get.label',
      new LabelEvent(data.orderId, client.data.payload),
    );
    
    // Processa primeira resposta (normalmente há apenas um listener)
    const response = promises.shift();
    
    // Retorna resposta formatada
    return {
      status: 'receive',
      orderId: data.orderId,
      data: response.data,
      errors: response.errors,
      timestamp: new Date().toISOString(),
    };
  } catch (e) {
    // ... tratamento de erro
  }
}

// integration.listener.ts
@OnEvent('get.label')
async handleOnLabelByOrderId(labelEvent: LabelEvent) {
  try {
    // Chama serviço SOAP para buscar etiquetas
    const confirm = await this.soapService.getLabels(
      labelEvent.orderId,
      labelEvent.payload,
    );
    
    return confirm; // Retorna { data: [...], errors: [...] }
  } catch (e) {
    const error = e as Error;
    this.logger.debug(error.message, error.stack);
    return {
      errors: [e], // Retorna erros no formato esperado
    };
  }
}

// soap-diagnostics-brazil.service.ts
async getLabels(id: number, payload: PayloadTokenDto) {
  // Busca o pedido completo
  const order = await this.ordersService.findById(id, payload);
  
  // Valida se o pedido está COMPLETED (só busca etiquetas de pedidos finalizados)
  this.checkOrderStatus(order, OrdersStatusEnum.COMPLETED);
  
  // Consulta API externa via SOAP
  const [response] = await this.diagnosticsBrazilWrapper.getLabels({
    request: {
      CodigoApoiado: this.appConfigService.dbLogin,
      CodigoSenhaIntegracao: this.appConfigService.dbPassword,
      NumeroAtendimentoApoiado: `${order.patientExams.prefix}-${order.patientExams.uuid}`,
    },
  });
  
  // Formata resposta da API externa
  const result = response.EnviaAmostrasResult as EnviaAmostrasResult;
  return this.formatConfirm(
    result.Confirmacao,
    order.patientExams.patient.dateBirth,
  );
}

// soap-diagnostics-brazil.service.ts
private formatConfirm(confirm: Confirmacao, dateBirth: Date | string) {
  return {
    // Array de etiquetas formatadas
    data: confirm.ConfirmacaoPedidov2.ct_ConfirmacaoPedidoEtiqueta_v2.flatMap(
      (obj) =>
        obj.Amostras
          ? obj.Amostras.ct_AmostraEtiqueta_v2.map((label) => ({
              numeroAmostra: label.NumeroAmostra,
              nomePaciente: label.NomePaciente,
              exames: label.Exames,
              grupoInterface: label.GrupoInterface,
              material: label.Material,
              volume: label.Volume,
              meioColeta: label.MeioColeta,
              regiaoColeta: label.RegiaoColeta,
              origem: label.Origem,
              dataNascimento: dateBirth,
              dataSistema: label.DataSistema,
              numeroAtendimento: obj.NumeroAtendimentoDB,
            }))
          : [],
    ),
    // Array de erros de integração
    errors: confirm.ConfirmacaoPedidov2.ct_ConfirmacaoPedidoEtiqueta_v2.flatMap(
      (error) =>
        error.ErroIntegracao
          ? error.ErroIntegracao.ct_ErroIntegracao_v2.map((e) => ({
              description: e.Descricao,
            }))
          : [],
    ),
  };
}

// Continuação do handleGetLabel
// Processa primeira resposta (normalmente há apenas um listener)
const response = promises.shift();

// Retorna resposta formatada
return {
  status: 'receive',
  orderId: data.orderId, // Para validação no frontend
  data: response.data,    // Array de etiquetas formatadas
  errors: response.errors, // Array de erros (se houver)
  timestamp: new Date().toISOString(),
};

// Label.tsx - Callback do socket.emit
(response: LabelResponseWs) => {
  // Valida se a resposta corresponde ao pedido correto
  if (response.orderId !== order.id) return;
  
  // Atualiza estado com as etiquetas
  setLabels(response.data);
  setIsLoading(false);
  
  // Exibe erros se houver
  if (response.errors?.length > 0) {
    addNotification({
      title: 'Atenção!!!',
      message: response.errors
        ?.map((error) => error.description)
        .join('|'),
      bg: 'danger',
      className: 'text-white',
      autohide: true,
    });
  }
}

// Label.tsx
socket.on('completed', (completed: Order) => {
  // Só busca se estiver aguardando impressão
  if (!isWindowPrint.current) return;
  
  // Valida condições antes de buscar
  if (
    order.id !== completed.id ||           // Deve ser o mesmo pedido
    labels.length !== 0 ||                 // Não deve ter etiquetas já carregadas
    completed.status.name !== OrdersStatusEnum.COMPLETED // Status deve ser COMPLETED
  ) return;
  
  // Busca etiquetas automaticamente
  getLabel();
});