Finalizar Pedido

// FinishOrder.tsx
async function handleFinish(id: number, status: OrdersStatusEnum) {
  socket?.emit(
    'finish.order',
    { orderId: id, status },
    (response: { status: 'receive' | 'refused'; message: string }) => {
      if (response.status === 'receive') {
        addNotification({
          title: 'Informação',
          message: `O pedido foi alterado para: ${status === OrdersStatusEnum.COMPLETED ? 'Completado' : 'Cancelado'}`,
          bg: 'primary',
          className: 'text-white',
          autohide: true,
        });
      }
      if (response.status === 'refused') {
        addNotification({
          title: 'Atenção!!!',
          message: response.message,
          bg: 'danger',
          className: 'text-white',
          autohide: true,
        });
      }
    }
  );
}

@SubscribeMessage('finish.order')
async handleOrderCompleted(
  @ConnectedSocket() client: Socket,
  @MessageBody() data: { orderId: number; status: string },
) {
  try {
    const payload = client.data.payload as PayloadTokenDto;
    
    // Busca o pedido
    const exists = await this.ordersService.findById(
      data.orderId,
      payload,
    );
    
    // Valida se o pedido existe e está em IN_PROGRESS
    if (
      !exists ||
      exists.status.name !== OrdersStatusEnum.IN_PROGRESS
    ) {
      return {
        status: 'refused',
        message: 'O pedido não foi encontrado ou não existe',
        timestamp: new Date().toISOString(),
      };
    }
    // ... continua no próximo passo
  } catch (e) {
    // ... tratamento de erro
  }
}

// Continuação do handleOrderCompleted
// Busca o status no banco
const status = await this.prisma.ordersStatus.findFirst({
  where: {
    name: data.status, // 'COMPLETED' ou 'CANCELED'
  },
});

// Valida se o status existe
if (!status) {
  return {
    status: 'refused',
    message: 'O status não foi encontrado ou não existe',
    timestamp: new Date().toISOString(),
  };
}
// ... continua no próximo passo

// Continuação do handleOrderCompleted
// Emite evento interno para processar a atualização
this.eventEmitter.emitAsync(
  'orders.finish',
  new OrderFinishEvent(
    exists.id,
    status.name as OrdersStatusEnum.COMPLETED | OrdersStatusEnum.CANCELED,
    payload,
  ),
);

// Remove da lista de progresso (notifica todos os clientes)
this.handleRemoveProgress(client, exists);

// Notifica via completed (ainda com status antigo, será atualizado pelo listener)
this.notifyOnEvent('completed', exists, payload);

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

// finish.listener.ts
@OnEvent('orders.finish')
async handleOrderFinish(orderFinishEvent: OrderFinishEvent) {
  try {
    // Busca o status no banco
    const status = await this.prisma.ordersStatus.findUnique({
      where: {
        name: orderFinishEvent.status, // COMPLETED ou CANCELED
      },
    });
    
    // Atualiza o pedido no banco (muda de IN_PROGRESS para COMPLETED ou CANCELED)
    await this.ordersService.finish(
      { id: orderFinishEvent.orderId, statusId: status.id },
      orderFinishEvent.payload,
    );
    
    // Emite evento adicional para notificar com pedido atualizado
    this.eventEmitter.emitAsync(
      'send.orders',
      new SendOrderEvent(
        'completed',
        orderFinishEvent.orderId,
        orderFinishEvent.payload,
      ),
    );
  } catch (e) {
    this.logger.debug(e);
  }
}

// orders.listener.ts
@OnEvent('send.orders')
async handleOnOrdersByCollect(sendEvent: SendOrderEvent) {
  // Busca o pedido atualizado (com novo status)
  const order = await this.ordersService.findById(
    sendEvent.order,
    sendEvent.payload,
  );
  
  // Notifica todos os clientes com o pedido atualizado
  await this.gateway.notifyOnEvent(
    sendEvent.event, // 'completed'
    order,
    sendEvent.payload,
  );
}

// ListInProgress.tsx
socket.on('remove.progress', (remove: Order) => {
  setOrders((prev) => 
    prev.filter((order) => order.id !== remove.id)
  );
});

// Side.tsx
const handleCompleted = (newOrder: Order) => {
  // Filtra por status antes de adicionar
  if (newOrder.status.name === searchParams.status) {
    setOrders((prev) =>
      // Previne duplicatas
      prev.some((o) => o.id === newOrder.id)
        ? prev
        // Adiciona no início da lista (pedidos mais recentes primeiro)
        : [newOrder, ...prev]
    );
  }
};

socket.on('completed', handleCompleted);