Carregar Revisão de Resultado

// page.tsx
socket.emit(
  'load.review',
  {
    resultsIntegrationUuid: uuid,
    reviewId: reviewId,
  },
  (response: any) => {
    // Callback apenas para tratar erros
    if (!response.status) {
      setHistory(undefined);
      setError(response.error);
    }
  }
);

// accounts.gateways.ts
@SubscribeMessage('load.review')
async handleLoadReview(
  @ConnectedSocket() client: Socket,
  @MessageBody() data: {
    resultsIntegrationUuid: string;
    reviewId: number;
  },
) {
  try {
    const payload = client.data.payload as PayloadTokenDto;
    
    // Busca revisão e histórico de mensagens
    const thread = await this.laboratoriesService.findOneReview(
      data.resultsIntegrationUuid,
      data.reviewId,
      payload,
    );
    // ... continua no próximo passo
  } catch (e) {
    // ... tratamento de erro
  }
}

// laboratories.service.ts
async findOneReview(
  resultsIntegrationUuid: string,
  reviewId: number,
  payload: PayloadTokenDto,
) {
  // Busca revisão no banco com validações
  const review = await this.prisma.resultsReview.findFirst({
    where: {
      id: reviewId,
      resultsIntegration: {
        uuid: resultsIntegrationUuid,
        deletedAt: null, // Não deletado
        order: {
          accountId: payload.accountId, // Mesma conta
        },
        statusReview: {
          name: {
            in: [StatusReview.ANALYZING, StatusReview.SENT], // Status válido
          },
        },
      },
    },
    select: {
      id: true,
      threadId: true, // ID do thread no OpenAI
      createdAt: true,
      updatedAt: true,
    },
  });
  
  if (!review) {
    throw new NotFoundException('Revisão não encontrada');
  }
  
  try {
    // Busca histórico de mensagens no OpenAI via threadId
    const messages = await this.openAiService.findHistory(
      review.threadId,
    );
    
    // Filtra mensagens ocultas
    return {
      id: review.id,
      messages: messages.filter(
        (message) => message.metadata.hidden !== 'true',
      ),
      createdAt: review.createdAt,
      updatedAt: review.updatedAt,
    };
  } catch (e) {
    throw new InternalServerErrorException('Erro ao buscar histórico');
  }
}

// accounts.gateways.ts - Continuação do handleLoadReview
// Propaga thread para todos os clientes da mesma conta
await this.notifyOnEvent('load.thread', thread, payload);

// Retorna sucesso via callback
return {
  status: true,
};

async notifyOnEvent(
  event: string,
  data: any,
  payload: PayloadTokenDto,
): Promise<any> {
  if (this._events.includes(event)) {
    // Envia para todos os clientes da mesma conta
    this.server
      .to(`${this.room}${payload.accountId}`)
      .emit(event, data);
  }
}

// this.room = 'orders.account.'
// Todos os clientes conectados da mesma accountId recebem o evento 'load.thread'

// accounts.gateways.ts - Continuação do handleLoadReview
} catch (e) {
  const { message } = e as Error;
  this.logger.debug(message);
  return {
    status: false,
    error: message,
  };
}

// page.tsx - Callback do socket.emit
(response: any) => {
  // Trata apenas erros
  if (!response.status) {
    setHistory(undefined);
    setError(response.error);
  }
  // Se status === true, aguarda evento 'load.thread' para receber dados
}

// page.tsx
socket.on('load.thread', (data: Thread) => {
  // Atualiza estado com histórico de mensagens
  setHistory(data);
  // Limpa erros
  setError(undefined);
});

// Remove listener ao desmontar
useEffect(() => {
  return () => {
    socket.off('load.thread');
  };
}, []);