Pedido Aguardando Coleta

// integration-diagnostics-brazil.service.ts
async send(payload: PayloadTokenDto, budget: Budget) {
    await this.prisma.$transaction(async (tx) => {
        // Busca status STANDBY
        const status = await this.ordersService.findByStatusOrder(
            OrdersStatusEnum.STANDBY,
        );

        // Cria order no banco
        const order = await tx.orders.create({
            data: {
                ulid: this.idService.nextUlid(),
                accountId: payload.accountId,
                createUserId: payload.sub,
                statusId: status.id,
            },
        });

        // Busca fornecedores dos procedimentos
        const procedureSuppliers =
            await this.laboratoriesService.findManyProceduresSuppliers(
                budget.budgetsProcedures.map((bp) => bp.procedure.id),
                payload,
            );

        // Cria PatientExams vinculado ao order
        await tx.patientsExams.create({
            data: {
                prefix: 'IMGM',
                patientId: budget.patient.id,
                orderId: order.id,
                procedureSupplier: {
                    connect: procedureSuppliers.map((ps) => ({ id: ps.id })),
                },
            },
        });

        // Vincula order ao budget
        await tx.budgets.update({
            where: { id: budget.id },
            data: {
                orders: { connect: { id: order.id } },
            },
        });

        // Emite evento interno para propagar via WebSocket
        await this.eventEmitter.emitAsync(
            'send.orders',
            new SendOrderEvent(
                'collect',
                await this.ordersService.findById(order.id, payload),
                payload,
            ),
        );
    });
}

// patient-exams.listener.ts
@OnEvent('patient-exams.create')
async handlePatientExamsCreate(orderEvent: OrderEvent) {
    try {
        // Cria PatientExams para o pedido
        await this.laboratoriesService.createPatientExams(
            orderEvent.sendDto,
            orderEvent.payload,
        );

        // Busca pedido completo e emite evento para propagar
        this.eventEmitter.emitAsync(
            'send.orders',
            new SendOrderEvent(
                'collect',
                await this.ordersService.findById(
                    orderEvent.sendDto.orderId,
                    orderEvent.payload,
                ),
                orderEvent.payload,
            ),
        );
    } catch (e) {
        this.logger.debug('Erro ao criar PatientExams', e);
    }
}

// orders.listener.ts
@OnEvent('send.orders')
async handleOnOrdersByCollect(sendEvent: SendOrderEvent) {
    // Verifica se order é número ou objeto
    const order =
        typeof sendEvent.order === 'number'
            ? await this.ordersService.findById(
                  sendEvent.order,
                  sendEvent.payload,
              )
            : sendEvent.order;

    // Propaga via broadcast para todos os clientes da conta
    await this.gateway.notifyOnEvent(
        sendEvent.event, // 'collect' neste caso
        order,
        sendEvent.payload,
    );
}

// accounts.gateways.ts
async notifyOnEvent(
    event: string,
    data: any,
    payload: PayloadTokenDto,
): Promise<any> {
    if (this._events.includes(event)) {
        this.server
            .to(`${this.room}${payload.accountId}`)
            .emit(event, data);
    }
}

// this.room = 'orders.account.'
// Envia para: orders.account.{accountId}
// Evento: 'collect'
// Dados: objeto Order completo

// ListStandby.tsx
useEffect(() => {
    if (!socket) return;
    
    // Solicita lista inicial
    socket.emit('get.orders.standby');
    
    // Escuta eventos
    socket.on('collect', (newData: Order) => {
        setOrders((prev) => {
            if (prev.find((d) => d.id === newData.id)) return prev;
            return [...prev, newData];
        });
    });
    
    socket.on('remove.standby', (remove: Order) => {
        setOrders((prev) => prev.filter((order) => order.id !== remove.id));
    });
    
    return () => {
        socket.off('collect');
        socket.off('remove.standby');
    };
}, [socket]);

// accounts.gateways.ts
@SubscribeMessage('get.orders.standby')
async handleOrdersStandby(@ConnectedSocket() client: Socket) {
    this.eventEmitter.emit(
        'load.orders.standby',
        new LoadOrdersEvent(client.id, client.data.payload),
    );
    
    return {
        status: 'receive',
    };
}

// orders.listener.ts
@OnEvent('load.orders.standby')
async handleOnLoadOrdersStandby({ to, payload }: LoadOrdersEvent) {
    try {
        // Busca todos os pedidos STANDBY
        const orders = await this.loadOrdersByStatus(
            OrdersStatusEnum.STANDBY,
            payload,
        );
        
        // Envia cada pedido individualmente para o cliente específico
        orders.map((order) =>
            this.gateway.notifyOnEventClient(to, 'collect', order),
        );
    } catch (e) {
        this.logger.debug('Erro ao buscar pedidos em standby', e);
    }
}

// accounts.gateways.ts
async notifyOnEventClient(to: string, event: string, data: any) {
    if (this._events.includes(event)) {
        this.server.to(to).emit(event, data);
    }
}

// to = client.id (ID do socket do cliente que solicitou)
// Evento: 'collect'
// Dados: objeto Order completo

// ListStandby.tsx
socket.on('collect', (newData: Order) => {
    setOrders((prev) => {
        // Verifica se pedido já existe (evita duplicatas)
        if (prev.find((d) => d.id === newData.id)) return prev;
        
        // Adiciona no final da lista (pedidos mais antigos primeiro)
        return [...prev, newData];
    });
});

// Contexto 1: Via integração (broadcast)
// - Emitido quando pedido é criado via integração
// - Enviado para TODOS os clientes da conta
// - Usa: notifyOnEvent('collect', order, payload)
// - Todos os clientes recebem o novo pedido em tempo real

// Contexto 2: Via PatientExams (broadcast)
// - Emitido quando PatientExams são criados
// - Enviado para TODOS os clientes da conta
// - Usa: notifyOnEvent('collect', order, payload)
// - Todos os clientes recebem o pedido atualizado

// Contexto 3: Via 'get.orders.standby' (cliente específico)
// - Emitido quando cliente solicita lista inicial
// - Enviado apenas para o CLIENTE que solicitou
// - Usa: notifyOnEventClient(to, 'collect', order)
// - Cliente recebe todos os pedidos STANDBY existentes