Pedido em Progresso

// accounts.gateways.ts
@SubscribeMessage('call')
async handleMessage(
    @ConnectedSocket() client: Socket,
    @MessageBody() data: UpdateOrderDto,
) {
    const payload = client.data.payload as PayloadTokenDto;
    
    // Valida se usuário já está coletando outro paciente
    const exists = await this.ordersService.existsOrder(
        OrdersStatusEnum.IN_PROGRESS,
        data.acceptepUserId ?? payload.sub,
        payload,
    );
    if (exists) {
        return {
            status: 'refused',
            message: 'O usuário já está coletando outro paciente',
        };
    }
    
    // Atualiza order para IN_PROGRESS
    const order = await this.ordersService.updateOrder(data, payload);

    // Emite evento progress via broadcast
    this.notifyOnEvent(
        'progress',
        await this.ordersService.findById(order.id, payload),
        client.data.payload,
    );

    return {
        status: 'receive',
        timestamp: new Date().toISOString(),
    };
}

// orders.service.ts
async updateOrder(updateOrderDto: UpdateOrderDto, payload: PayloadTokenDto) {
    // Valida permissões se atribuir para outro usuário
    if (updateOrderDto.acceptepUserId) {
        const check = await this.permissionsService.hasPermissions(
            payload,
            [ASSIGN_LABORATORY],
        );
        if (!check) throw new UnauthorizedException();
    }
    
    // Atualiza pedido no banco
    const order = await this.prisma.orders.update({
        where: {
            id: updateOrderDto.id,
            accountId: payload.accountId,
            status: { name: OrdersStatusEnum.STANDBY },
        },
        data: {
            status: { connect: { name: OrdersStatusEnum.IN_PROGRESS } },
            acceptUser: {
                connect: { id: updateOrderDto.acceptepUserId ?? payload.sub },
            },
        },
    });
    return order;
}

// 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: 'progress'
// Dados: objeto Order completo

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

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

// orders.listener.ts
@OnEvent('load.orders.progress')
async handleOnLoadOrdersProgress({ to, payload }: LoadOrdersEvent) {
    try {
        // Busca todos os pedidos IN_PROGRESS
        const orders = await this.loadOrdersByStatus(
            OrdersStatusEnum.IN_PROGRESS,
            payload,
        );
        
        // Envia cada pedido individualmente para o cliente específico
        orders.map((order) =>
            this.gateway.notifyOnEventClient(to, 'progress', order),
        );
    } catch (e) {
        this.logger.debug('Erro ao buscar pedidos em progresso', 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: 'progress'
// Dados: objeto Order completo

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

// Contexto 1: Via 'call' (broadcast)
// - Emitido quando pedido é chamado para coleta
// - Enviado para TODOS os clientes da conta
// - Usa: notifyOnEvent('progress', order, payload)
// - Todos os clientes recebem o novo pedido em tempo real

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