Criar Etiquetas do Pedido

// Label.tsx
const validate = useCallback(() => {
  if (!socket) return;

  setIsLoading(true);
  // Define flag para busca automática de etiquetas quando pedido for completado
  isWindowPrint.current = true;
  
  socket.emit(
    'create.label',
    {
      orderId: order.id,
      fields: {
        priority,
        height,
        weight,
        procedures,
      },
      token,
    },
    (data: ValiditionsResponseWs) => {
      console.log('Validation response:', data);
      
      // Se há integrações pendentes, remove loading (usuário precisa ajustar dados)
      if (data.integrations.length > 0) setIsLoading(false);

      // Trata erros
      if (data.status === 'refused') {
        setIsLoading(false);
        addNotification({
          title: 'Atenção',
          message: data.message,
          bg: 'danger',
          className: 'text-white',
          autohide: true,
        });
      }
      // Se não há integrações pendentes, loading continua (aguardando geração de etiquetas)
    }
  );
}, [socket, order.id, priority, height, weight, procedures, token, addNotification]);

// procedures-required.pipe.ts
async transform({
  orderId,
  fields,
  token,
}: {
  orderId: number;
  fields: CamposAdicionais;
  token: string;
}): Promise<any> {
  try {
    // Valida e decodifica o token JWT
    const payload = await this.jwtService.verifyAsync(token, {
      secret: this.jwtConfiguration.access.secret,
      audience: this.jwtConfiguration.access.audience,
      issuer: this.jwtConfiguration.access.issuer,
    });
    
    // Valida orderId
    if (orderId === undefined || orderId === null) {
      throw new WsException('orderId is required');
    }
    
    const parsedOrderId = Number(orderId);
    if (isNaN(parsedOrderId)) {
      throw new WsException('orderId must be a valid number');
    }
    
    // Busca o pedido completo
    const order = await this.ordersService.findById(
      parsedOrderId,
      payload,
    );
    
    // Extrai IDs dos procedimentos do pedido
    const procedureIds = order.patientExams.procedureSupplier.map(
      (ps) => ps.procedureId,
    );
    
    // Busca integrações relacionadas aos procedimentos
    const integrations = await this.integrationDBService.findByProceduresIds(
      procedureIds,
      payload,
    );
    
    // Retorna dados transformados para o próximo pipe
    return {
      orderId,
      integrations,
      fields,
      token,
    };
  } catch (e) {
    throw new WsException('Erro ao procurar os procedimentos da integração');
  }
}

// field-validator.pipe.ts
async transform({
  orderId,
  integrations,
  fields,
  token,
}: {
  orderId: number;
  integrations: Array<IntegrationDiagnosticsBrazil & { procedure: Procedures }>;
  fields: CamposAdicionais;
  token: string;
}) {
  try {
    // Valida token JWT novamente
    const payload = await this.jwtService.verifyAsync(token, {
      secret: this.jwtConfiguration.access.secret,
      audience: this.jwtConfiguration.access.audience,
      issuer: this.jwtConfiguration.access.issuer,
    });
    
    // Filtra integrações válidas
    const integrationsFiltred = await Promise.all(
      integrations.flatMap(async (integration) => {
        // Busca campos específicos do procedimento em fields.procedures
        const fieldFind = fields.procedures.find(
          (field) => field.procedureId === integration.procedureId,
        );
        
        // Valida se a integração está configurada corretamente com os campos fornecidos
        const find = await this.integrationService.findByProcedureIdAndFields(
          integration.procedureId,
          {
            ...fieldFind,
            height: fields.height,
            weight: fields.weight,
          },
          payload,
        );
        
        // Mantém apenas integrações que passam na validação
        return find ? [integration] : [];
      }),
    );
    
    // Retorna dados filtrados
    return {
      orderId,
      integrations: integrationsFiltred.flat(),
      fields: fields,
    };
  } catch (e) {
    throw new WsException('Erro ao validar os procedimentos da integração');
  }
}

// accounts.gateways.ts
@SubscribeMessage('create.label')
async handleGenerateLabel(
  @ConnectedSocket() client: Socket,
  @MessageBody(ProceduresRequiredPipe, FieldValidatorPipe)
  data: {
    orderId: number;
    integrations: Array<
      IntegrationDiagnosticsBrazil & {
        procedure: Procedures;
      }
    >;
    fields: CamposAdicionais;
  },
): Promise<ResponseWs> {
  try {
    // Se não há integrações pendentes (todas foram validadas), gera etiquetas
    if (data.integrations.length === 0) {
      // Emite evento interno para gerar etiquetas (processamento assíncrono)
      this.eventEmitter.emit(
        'create.label',
        new LabelEvent(
          data.orderId,
          client.data.payload,
          data.fields,
        ),
      );
    }
    
    // Retorna resposta sempre (independente se gerou etiquetas ou não)
    return {
      status: 'receive',
      integrations: data.integrations, // Array vazio se todas foram validadas
      timestamp: new Date().toISOString(),
    };
  } catch (e) {
    // ... tratamento de erro
  }
}

// integration.listener.ts
@OnEvent('create.label')
async handleOnGenerateLabel(labelEvent: LabelEvent) {
  try {
    // Gera etiquetas via API SOAP externa (processamento assíncrono)
    const confirm = await this.soapService.generateLabel(
      labelEvent.orderId,
      labelEvent.payload,
      labelEvent.additionals, // Campos adicionais (priority, height, weight, procedures)
    );
  } catch (e) {
    this.logger.debug(e);
  }
}

// soap-diagnostics-brazil.service.ts
async generateLabel(id: number, payload: PayloadTokenDto, additionals?: CamposAdicionais) {
  // Busca o pedido completo
  const order = await this.ordersService.findById(id, payload);
  
  // Valida se o pedido está IN_PROGRESS (só gera etiquetas de pedidos em coleta)
  this.checkOrderStatus(order, OrdersStatusEnum.IN_PROGRESS);
  
  // Monta dados do pedido com campos adicionais
  const requestData = {
    // Dados do paciente
    patient: order.patientExams.patient,
    // Procedimentos com campos adicionais (volume, region por procedimento)
    procedures: order.patientExams.procedureSupplier.map((ps) => ({
      ...ps,
      volume: additionals?.procedures?.find(p => p.procedureId === ps.procedureId)?.volume,
      region: additionals?.procedures?.find(p => p.procedureId === ps.procedureId)?.region,
    })),
    // Campos globais
    priority: additionals?.priority,
    height: additionals?.height,
    weight: additionals?.weight,
  };
  
  // Chama API SOAP externa (DiagnosticsBrazil)
  const [response] = await this.diagnosticsBrazilWrapper.recebeAtendimento({
    request: requestData,
  });
  
  // Valida resposta da API
  const validationResult = await this.validationService.validate(response);
  
  if (!validationResult.isValid) {
    // Se validação falhar, emite evento de erro
    this.eventEmitter.emit('orders.failed', {
      orderId: id,
      errors: validationResult.errors,
    });
    return;
  }
  
  // Se validação passar, completa o pedido automaticamente
  this.eventEmitter.emit('orders.finish', {
    orderId: id,
    status: OrdersStatusEnum.COMPLETED,
    payload,
  });
  
  // Formata resposta das etiquetas geradas
  return this.formatConfirm(response.Confirmacao);
}

// Label.tsx - Callback do socket.emit
(data: ValiditionsResponseWs) => {
  console.log('Validation response:', data);
  
  // Se há integrações pendentes, remove loading (usuário precisa ajustar dados)
  if (data.integrations.length > 0) {
    setIsLoading(false);
  }
  // Se não há integrações pendentes, loading continua (aguardando geração de etiquetas)

  // Trata erros
  if (data.status === 'refused') {
    setIsLoading(false);
    addNotification({
      title: 'Atenção',
      message: data.message,
      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();
});