Order Management System

const createOrderSchema = z.object({
  billing_info: z.object({
    first_name: z.string(),
    last_name: z.string(),
    email: z.string().email(),
    phone: z.string(),
    identification_type: z.string(),
    identification: z.string(),
  }),
  shipping_info: z.object({
    first_name: z.string(),
    last_name: z.string(),
    address_1: z.string(),
    city_code: z.string(),
    subdivision_code: z.string(),
    country_code: z.string(),
    phone: z.string(),
    postal_code: z.string().optional().default(""),
  }),
  line_items: z.array(z.object({
    sku: z.string(),
    name: z.string(),
    unit_price: z.number(),
    quantity: z.number(),
    weight: z.number(),
    dimensions_unit: z.enum(['CM']),
    height: z.number(),
    width: z.number(),
    length: z.number(),
  })),
  payment_method_code: z.enum(['COD', 'EXTERNAL_PAYMENT']),
  external_order_id: z.string(),
});

const result = createOrderSchema.safeParse(req.body);
if (!result.success) {
  return res.status(400).json({
    error: 'Datos inválidos',
    details: result.error.format()
  });
}

try {
  await InventoryService.reserveStock(orderData.line_items);
} catch (stockError) {
  return res.status(409).json({ error: stockError.message });
}

const user = await prisma.user.upsert({
  where: { email },
  update: { name: fullName },
  create: { email, name: fullName, role: 'CUSTOMER' }
});

const dbOrder = await prisma.order.create({
  data: {
    status: 'PENDING',
    paymentMethod: orderData.payment_method_code === 'COD' ? 'COD' : 'WOMPI',
    subtotal: orderData.line_items.reduce((sum, item) => 
      sum + (item.unit_price * item.quantity), 0
    ),
    userId: user.id,
    customerName: fullName,
    customerEmail: email,
    shippingAddress: orderData.shipping_info,
    items: {
      create: orderData.line_items.map(item => ({
        product: { connect: { id: dbProduct.id } },
        sku: item.sku,
        name: item.name,
        price: item.unit_price,
        quantity: item.quantity
      }))
    }
  }
});

const logisticsPayload = {
  ...orderData,
  external_order_id: String(dbOrder.readableId)
};

shipmentData = await LogisticsManager.createShipment(logisticsPayload);

const updatedOrder = await prisma.order.update({
  where: { id: dbOrder.id },
  data: {
    externalId: shipmentData.external_id,
    total: shipmentData.total || 0,
    shippingCost: shipmentData.shipping_cost || 0,
    carrier: shipmentData.carrier_name,
    trackingNumber: shipmentData.trackingNumber || null,
  }
});

const handleGenerateLabel = async (orderId: string) => {
  setGeneratingLabel(orderId);
  
  const res = await fetch('/api/admin/generate-label', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({ orderIds: [orderId] })
  });
  
  const data = await res.json();
  
  if (res.status === 202) {
    toast({ 
      title: "Creating Label...",
      description: "Carrier is processing. Retry in a few seconds."
    });
    return;
  }
  
  if (data.data) {
    window.open(data.data, '_blank'); // Open PDF
    toast({ title: "Label Generated" });
    fetchData(); // Refresh order list
  }
};

const handleRequestPickup = async (orderId: string) => {
  if (!confirm('¿Solicitar recogida para esta orden?')) return;
  
  const res = await fetch('/api/admin/request-pickup', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({ orderIds: [orderId] })
  });
  
  const data = await res.json();
  if (!res.ok) throw new Error(data.error);
  
  toast({
    title: "Pickup Requested",
    description: "Carrier has been notified."
  });
};