Improve the frontend and fix TODOs

services/inventory/scripts/demo/seed_demo_stock.py

@@ -34,7 +34,7 @@ from sqlalchemy.orm import sessionmaker
 from sqlalchemy import select
 import structlog
 
-from app.models.inventory import Ingredient, Stock
+from app.models.inventory import Ingredient, Stock, StockMovement, StockMovementType
 
 # Configure logging
 structlog.configure(
@@ -220,6 +220,438 @@ async def create_stock_batches_for_ingredient(
     return stocks
 
 
+async def create_waste_movements_for_tenant(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    base_date: datetime
+) -> list:
+    """
+    Create realistic waste stock movements for the past 30 days
+
+    Args:
+        db: Database session
+        tenant_id: UUID of the tenant
+        base_date: Base reference date for movement calculations
+
+    Returns:
+        List of created StockMovement instances
+    """
+    # Get all stock for this tenant (including expired)
+    result = await db.execute(
+        select(Stock, Ingredient).join(
+            Ingredient, Stock.ingredient_id == Ingredient.id
+        ).where(
+            Stock.tenant_id == tenant_id
+        )
+    )
+    stock_items = result.all()
+
+    if not stock_items:
+        return []
+
+    movements = []
+    waste_reasons = [
+        ("spoilage", 0.40),  # 40% of waste is spoilage
+        ("expired", 0.30),   # 30% is expiration
+        ("damage", 0.20),    # 20% is damage
+        ("contamination", 0.10)  # 10% is contamination
+    ]
+
+    # Create waste movements for expired stock
+    for stock, ingredient in stock_items:
+        if stock.is_expired and stock.current_quantity > 0:
+            # Create waste movement for expired stock
+            waste_quantity = stock.current_quantity
+            movement_date = stock.expiration_date + timedelta(days=random.randint(1, 3))
+
+            movement = StockMovement(
+                id=uuid.uuid4(),
+                tenant_id=tenant_id,
+                ingredient_id=ingredient.id,
+                stock_id=stock.id,
+                movement_type=StockMovementType.WASTE,
+                quantity=waste_quantity,
+                unit_cost=stock.unit_cost,
+                total_cost=stock.unit_cost * Decimal(str(waste_quantity)) if stock.unit_cost else None,
+                reason_code="expired",
+                notes=f"Lote {stock.batch_number} caducado - movimiento automático de desperdicio",
+                reference_number=f"WASTE-EXP-{stock.batch_number}",
+                movement_date=movement_date,
+                created_at=movement_date,
+                created_by=None  # System-generated
+            )
+            movements.append(movement)
+
+    # Create additional random waste movements for the past 30 days
+    # to show waste patterns from spoilage, damage, etc.
+    num_waste_movements = random.randint(8, 15)  # 8-15 waste incidents in 30 days
+
+    for i in range(num_waste_movements):
+        # Select random non-expired stock
+        available_stock = [(s, i) for s, i in stock_items if not s.is_expired and s.current_quantity > 5.0]
+        if not available_stock:
+            continue
+
+        stock, ingredient = random.choice(available_stock)
+
+        # Random date in the past 30 days
+        days_ago = random.randint(1, 30)
+        movement_date = base_date - timedelta(days=days_ago)
+
+        # Random waste quantity (1-10% of current stock)
+        waste_percentage = random.uniform(0.01, 0.10)
+        waste_quantity = round(stock.current_quantity * waste_percentage, 2)
+
+        # Select random waste reason
+        reason, _ = random.choices(
+            waste_reasons,
+            weights=[w for _, w in waste_reasons]
+        )[0]
+
+        # Create waste movement
+        movement = StockMovement(
+            id=uuid.uuid4(),
+            tenant_id=tenant_id,
+            ingredient_id=ingredient.id,
+            stock_id=stock.id,
+            movement_type=StockMovementType.WASTE,
+            quantity=waste_quantity,
+            unit_cost=stock.unit_cost,
+            total_cost=stock.unit_cost * Decimal(str(waste_quantity)) if stock.unit_cost else None,
+            reason_code=reason,
+            notes=f"Desperdicio de {ingredient.name} por {reason}",
+            reference_number=f"WASTE-{reason.upper()}-{i+1:03d}",
+            movement_date=movement_date,
+            created_at=movement_date,
+            created_by=None  # System-generated
+        )
+        movements.append(movement)
+
+    return movements
+
+
+async def create_purchase_movements_for_stock(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    base_date: datetime
+) -> list:
+    """
+    Create PURCHASE movements for all stock batches
+
+    Each stock batch should have a corresponding PURCHASE movement
+    representing when it was received from the supplier.
+
+    Args:
+        db: Database session
+        tenant_id: UUID of the tenant
+        base_date: Base reference date for movement calculations
+
+    Returns:
+        List of created StockMovement instances
+    """
+    # Get all stock for this tenant
+    result = await db.execute(
+        select(Stock, Ingredient).join(
+            Ingredient, Stock.ingredient_id == Ingredient.id
+        ).where(
+            Stock.tenant_id == tenant_id
+        )
+    )
+    stock_items = result.all()
+
+    if not stock_items:
+        return []
+
+    movements = []
+
+    for stock, ingredient in stock_items:
+        # Create PURCHASE movement for each stock batch
+        # Movement date is the received date of the stock
+        movement_date = stock.received_date
+
+        movement = StockMovement(
+            id=uuid.uuid4(),
+            tenant_id=tenant_id,
+            ingredient_id=ingredient.id,
+            stock_id=stock.id,
+            movement_type=StockMovementType.PURCHASE,
+            quantity=stock.current_quantity + stock.reserved_quantity,  # Total received
+            unit_cost=stock.unit_cost,
+            total_cost=stock.total_cost,
+            quantity_before=0.0,  # Was zero before purchase
+            quantity_after=stock.current_quantity + stock.reserved_quantity,
+            reference_number=f"PO-{movement_date.strftime('%Y%m')}-{random.randint(1000, 9999)}",
+            supplier_id=stock.supplier_id,
+            notes=f"Compra de {ingredient.name} - Lote {stock.batch_number}",
+            movement_date=movement_date,
+            created_at=movement_date,
+            created_by=None  # System-generated
+        )
+        movements.append(movement)
+
+    return movements
+
+
+async def create_production_use_movements(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    base_date: datetime
+) -> list:
+    """
+    Create realistic PRODUCTION_USE movements for the past 30 days
+
+    Simulates ingredients being consumed in production runs.
+
+    Args:
+        db: Database session
+        tenant_id: UUID of the tenant
+        base_date: Base reference date for movement calculations
+
+    Returns:
+        List of created StockMovement instances
+    """
+    # Get all available stock for this tenant
+    result = await db.execute(
+        select(Stock, Ingredient).join(
+            Ingredient, Stock.ingredient_id == Ingredient.id
+        ).where(
+            Stock.tenant_id == tenant_id,
+            Stock.is_available == True,
+            Stock.current_quantity > 10.0  # Only use stock with sufficient quantity
+        )
+    )
+    stock_items = result.all()
+
+    if not stock_items:
+        return []
+
+    movements = []
+
+    # Create 15-25 production use movements spread over 30 days
+    num_production_runs = random.randint(15, 25)
+
+    production_types = [
+        ("Pan Rústico", 20.0, 50.0),  # 20-50 kg flour
+        ("Pan de Molde", 15.0, 40.0),
+        ("Croissants", 10.0, 30.0),
+        ("Baguettes", 25.0, 60.0),
+        ("Bollería Variada", 12.0, 35.0),
+        ("Pan Integral", 18.0, 45.0)
+    ]
+
+    for i in range(num_production_runs):
+        # Select random stock item
+        if not stock_items:
+            break
+
+        stock, ingredient = random.choice(stock_items)
+
+        # Random date in the past 30 days
+        days_ago = random.randint(1, 30)
+        movement_date = base_date - timedelta(days=days_ago)
+
+        # Random production type and quantity
+        production_name, min_qty, max_qty = random.choice(production_types)
+
+        # Production quantity (5-20% of current stock, within min/max range)
+        use_percentage = random.uniform(0.05, 0.20)
+        use_quantity = round(min(
+            stock.current_quantity * use_percentage,
+            random.uniform(min_qty, max_qty)
+        ), 2)
+
+        # Ensure we don't consume more than available
+        if use_quantity > stock.available_quantity:
+            use_quantity = round(stock.available_quantity * 0.5, 2)
+
+        if use_quantity < 1.0:
+            continue
+
+        # Create production use movement
+        movement = StockMovement(
+            id=uuid.uuid4(),
+            tenant_id=tenant_id,
+            ingredient_id=ingredient.id,
+            stock_id=stock.id,
+            movement_type=StockMovementType.PRODUCTION_USE,
+            quantity=use_quantity,
+            unit_cost=stock.unit_cost,
+            total_cost=stock.unit_cost * Decimal(str(use_quantity)) if stock.unit_cost else None,
+            quantity_before=stock.current_quantity,
+            quantity_after=stock.current_quantity - use_quantity,
+            reference_number=f"PROD-{movement_date.strftime('%Y%m%d')}-{i+1:03d}",
+            notes=f"Producción de {production_name} - Consumo de {ingredient.name}",
+            movement_date=movement_date,
+            created_at=movement_date,
+            created_by=None  # System-generated
+        )
+        movements.append(movement)
+
+        # Update stock quantity for realistic simulation (don't commit, just for calculation)
+        stock.current_quantity -= use_quantity
+        stock.available_quantity -= use_quantity
+
+    return movements
+
+
+async def create_adjustment_movements(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    base_date: datetime
+) -> list:
+    """
+    Create inventory ADJUSTMENT movements
+
+    Represents inventory counts and corrections.
+
+    Args:
+        db: Database session
+        tenant_id: UUID of the tenant
+        base_date: Base reference date for movement calculations
+
+    Returns:
+        List of created StockMovement instances
+    """
+    # Get all stock for this tenant
+    result = await db.execute(
+        select(Stock, Ingredient).join(
+            Ingredient, Stock.ingredient_id == Ingredient.id
+        ).where(
+            Stock.tenant_id == tenant_id,
+            Stock.current_quantity > 5.0
+        )
+    )
+    stock_items = result.all()
+
+    if not stock_items:
+        return []
+
+    movements = []
+
+    adjustment_reasons = [
+        ("inventory_count", "Conteo de inventario mensual"),
+        ("correction", "Corrección de entrada incorrecta"),
+        ("shrinkage", "Ajuste por merma natural"),
+        ("reconciliation", "Reconciliación de stock")
+    ]
+
+    # Create 3-5 adjustment movements
+    num_adjustments = random.randint(3, 5)
+
+    for i in range(num_adjustments):
+        if not stock_items:
+            break
+
+        stock, ingredient = random.choice(stock_items)
+
+        # Random date in the past 30 days
+        days_ago = random.randint(5, 30)
+        movement_date = base_date - timedelta(days=days_ago)
+
+        # Random adjustment (±5% of current stock)
+        adjustment_percentage = random.uniform(-0.05, 0.05)
+        adjustment_quantity = round(stock.current_quantity * adjustment_percentage, 2)
+
+        if abs(adjustment_quantity) < 0.1:
+            continue
+
+        reason_code, reason_note = random.choice(adjustment_reasons)
+
+        # Create adjustment movement
+        movement = StockMovement(
+            id=uuid.uuid4(),
+            tenant_id=tenant_id,
+            ingredient_id=ingredient.id,
+            stock_id=stock.id,
+            movement_type=StockMovementType.ADJUSTMENT,
+            quantity=abs(adjustment_quantity),
+            unit_cost=stock.unit_cost,
+            total_cost=stock.unit_cost * Decimal(str(abs(adjustment_quantity))) if stock.unit_cost else None,
+            quantity_before=stock.current_quantity,
+            quantity_after=stock.current_quantity + adjustment_quantity,
+            reference_number=f"ADJ-{movement_date.strftime('%Y%m%d')}-{i+1:03d}",
+            reason_code=reason_code,
+            notes=f"{reason_note} - {ingredient.name}: {'+' if adjustment_quantity > 0 else ''}{adjustment_quantity:.2f} {ingredient.unit_of_measure.value}",
+            movement_date=movement_date,
+            created_at=movement_date,
+            created_by=None  # System-generated
+        )
+        movements.append(movement)
+
+    return movements
+
+
+async def create_initial_stock_movements(
+    db: AsyncSession,
+    tenant_id: uuid.UUID,
+    base_date: datetime
+) -> list:
+    """
+    Create INITIAL_STOCK movements for opening inventory
+
+    Represents the initial inventory when the system was set up.
+
+    Args:
+        db: Database session
+        tenant_id: UUID of the tenant
+        base_date: Base reference date for movement calculations
+
+    Returns:
+        List of created StockMovement instances
+    """
+    # Get all stock for this tenant
+    result = await db.execute(
+        select(Stock, Ingredient).join(
+            Ingredient, Stock.ingredient_id == Ingredient.id
+        ).where(
+            Stock.tenant_id == tenant_id
+        )
+    )
+    stock_items = result.all()
+
+    if not stock_items:
+        return []
+
+    movements = []
+
+    # Create initial stock for 20% of ingredients (opening inventory)
+    # Date is 60-90 days before base_date
+    initial_stock_date = base_date - timedelta(days=random.randint(60, 90))
+
+    # Select 20% of stock items randomly
+    num_initial = max(1, int(len(stock_items) * 0.20))
+    initial_stock_items = random.sample(stock_items, num_initial)
+
+    for stock, ingredient in initial_stock_items:
+        # Initial quantity (50-80% of current quantity)
+        initial_quantity = round(stock.current_quantity * random.uniform(0.5, 0.8), 2)
+
+        if initial_quantity < 1.0:
+            continue
+
+        # Create initial stock movement
+        movement = StockMovement(
+            id=uuid.uuid4(),
+            tenant_id=tenant_id,
+            ingredient_id=ingredient.id,
+            stock_id=stock.id,
+            movement_type=StockMovementType.INITIAL_STOCK,
+            quantity=initial_quantity,
+            unit_cost=stock.unit_cost,
+            total_cost=stock.unit_cost * Decimal(str(initial_quantity)) if stock.unit_cost else None,
+            quantity_before=0.0,
+            quantity_after=initial_quantity,
+            reference_number=f"INIT-{initial_stock_date.strftime('%Y%m%d')}",
+            notes=f"Inventario inicial de {ingredient.name}",
+            movement_date=initial_stock_date,
+            created_at=initial_stock_date,
+            created_by=None  # System-generated
+        )
+        movements.append(movement)
+
+    return movements
+
+
 async def seed_stock_for_tenant(
     db: AsyncSession,
     tenant_id: uuid.UUID,
@@ -244,6 +676,37 @@ async def seed_stock_for_tenant(
     logger.info(f"Base Reference Date: {base_date.isoformat()}")
     logger.info("─" * 80)
 
+    # Check if stock already exists for this tenant (idempotency)
+    existing_stock_check = await db.execute(
+        select(Stock).where(Stock.tenant_id == tenant_id).limit(1)
+    )
+    existing_stock = existing_stock_check.scalars().first()
+
+    if existing_stock:
+        logger.warning(f"Stock already exists for tenant {tenant_id} - skipping to prevent duplicates")
+        # Count existing stock for reporting
+        stock_count_result = await db.execute(
+            select(Stock).where(Stock.tenant_id == tenant_id)
+        )
+        existing_stocks = stock_count_result.scalars().all()
+
+        return {
+            "tenant_id": str(tenant_id),
+            "tenant_name": tenant_name,
+            "stock_created": 0,
+            "ingredients_processed": 0,
+            "skipped": True,
+            "existing_stock_count": len(existing_stocks),
+            "expired_count": 0,
+            "expiring_soon_count": 0,
+            "movements_created": 0,
+            "purchase_movements": 0,
+            "initial_movements": 0,
+            "production_movements": 0,
+            "adjustment_movements": 0,
+            "waste_movements": 0
+        }
+
     # Get all ingredients for this tenant
     result = await db.execute(
         select(Ingredient).where(
@@ -282,12 +745,62 @@ async def seed_stock_for_tenant(
 
         logger.debug(f"   ✅ Created {len(stocks)} stock batches for: {ingredient.name}")
 
-    # Commit all changes
+    # Commit stock changes
     await db.commit()
 
+    # Create all types of stock movements
+    logger.info(f"   📦 Creating stock movements...")
+
+    # 1. Create PURCHASE movements (for all stock received)
+    logger.info(f"      💰 Creating purchase movements...")
+    purchase_movements = await create_purchase_movements_for_stock(db, tenant_id, base_date)
+    for movement in purchase_movements:
+        db.add(movement)
+
+    # 2. Create INITIAL_STOCK movements (opening inventory)
+    logger.info(f"      📋 Creating initial stock movements...")
+    initial_movements = await create_initial_stock_movements(db, tenant_id, base_date)
+    for movement in initial_movements:
+        db.add(movement)
+
+    # 3. Create PRODUCTION_USE movements (ingredients consumed)
+    logger.info(f"      🍞 Creating production use movements...")
+    production_movements = await create_production_use_movements(db, tenant_id, base_date)
+    for movement in production_movements:
+        db.add(movement)
+
+    # 4. Create ADJUSTMENT movements (inventory corrections)
+    logger.info(f"      🔧 Creating adjustment movements...")
+    adjustment_movements = await create_adjustment_movements(db, tenant_id, base_date)
+    for movement in adjustment_movements:
+        db.add(movement)
+
+    # 5. Create WASTE movements (spoilage, expiration, etc.)
+    logger.info(f"      🗑️  Creating waste movements...")
+    waste_movements = await create_waste_movements_for_tenant(db, tenant_id, base_date)
+    for movement in waste_movements:
+        db.add(movement)
+
+    # Commit all movements
+    await db.commit()
+
+    total_movements = (
+        len(purchase_movements) +
+        len(initial_movements) +
+        len(production_movements) +
+        len(adjustment_movements) +
+        len(waste_movements)
+    )
+
     logger.info(f"   📊 Total Stock Batches Created: {total_stock_created}")
     logger.info(f"   ⚠️  Expired Batches: {expired_count}")
     logger.info(f"   🔔 Expiring Soon (≤3 days): {expiring_soon_count}")
+    logger.info(f"   📝 Stock Movements Created: {total_movements}")
+    logger.info(f"      💰 Purchase: {len(purchase_movements)}")
+    logger.info(f"      📋 Initial Stock: {len(initial_movements)}")
+    logger.info(f"      🍞 Production Use: {len(production_movements)}")
+    logger.info(f"      🔧 Adjustments: {len(adjustment_movements)}")
+    logger.info(f"      🗑️  Waste: {len(waste_movements)}")
     logger.info("")
 
     return {
@@ -296,7 +809,13 @@ async def seed_stock_for_tenant(
         "stock_created": total_stock_created,
         "ingredients_processed": len(ingredients),
         "expired_count": expired_count,
-        "expiring_soon_count": expiring_soon_count
+        "expiring_soon_count": expiring_soon_count,
+        "movements_created": total_movements,
+        "purchase_movements": len(purchase_movements),
+        "initial_movements": len(initial_movements),
+        "production_movements": len(production_movements),
+        "adjustment_movements": len(adjustment_movements),
+        "waste_movements": len(waste_movements)
     }
 
 
@@ -339,6 +858,7 @@ async def seed_stock(db: AsyncSession):
     total_stock = sum(r["stock_created"] for r in results)
     total_expired = sum(r["expired_count"] for r in results)
     total_expiring_soon = sum(r["expiring_soon_count"] for r in results)
+    total_movements = sum(r.get("movements_created", r.get("waste_movements_created", 0)) for r in results)
 
     logger.info("=" * 80)
     logger.info("✅ Demo Stock Seeding Completed")
@@ -350,6 +870,7 @@ async def seed_stock(db: AsyncSession):
         "total_stock_created": total_stock,
         "total_expired": total_expired,
         "total_expiring_soon": total_expiring_soon,
+        "total_movements_created": total_movements,
         "results": results
     }
 
@@ -398,15 +919,18 @@ async def main():
             logger.info(f"   ✅ Total stock batches:  {result['total_stock_created']}")
             logger.info(f"   ⚠️  Expired batches:  {result['total_expired']}")
             logger.info(f"   🔔 Expiring soon (≤3 days):  {result['total_expiring_soon']}")
+            logger.info(f"   📝 Total movements:  {result['total_movements_created']}")
             logger.info("")
 
             # Print per-tenant details
             for tenant_result in result['results']:
+                movements_count = tenant_result.get('movements_created', tenant_result.get('waste_movements_created', 0))
                 logger.info(
                     f"   {tenant_result['tenant_name']}: "
                     f"{tenant_result['stock_created']} batches "
                     f"({tenant_result['expired_count']} expired, "
-                    f"{tenant_result['expiring_soon_count']} expiring soon)"
+                    f"{tenant_result['expiring_soon_count']} expiring soon, "
+                    f"{movements_count} movements)"
                 )
 
             logger.info("")