bakery-admin/bakery-ia
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Improve the demo feature of the project

Browse Source
This commit is contained in:
Urtzi Alfaro
2025-10-12 18:47:33 +02:00
parent dbc7f2fa0d
commit 7556a00db7
168 changed files with 10102 additions and 18869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

447
services/recipes/scripts/demo/recetas_es.json Normal file
View File

@@ -0,0 +1,447 @@
{
"recetas": [
{
"id": "30000000-0000-0000-0000-000000000001",
"finished_product_id": "20000000-0000-0000-0000-000000000001",
"name": "Baguette Francesa Tradicional",
"category": "Panes",
"cuisine_type": "Francesa",
"difficulty_level": 2,
"yield_quantity": 10.0,
"yield_unit": "units",
"prep_time_minutes": 20,
"cook_time_minutes": 25,
"total_time_minutes": 165,
"rest_time_minutes": 120,
"description": "Baguette francesa tradicional con corteza crujiente y miga alveolada. Perfecta para acompañar cualquier comida.",
"instructions": {
"steps": [
{
"step": 1,
"title": "Amasado",
"description": "Mezclar harina, agua, sal y levadura. Amasar durante 15 minutos hasta obtener una masa lisa y elástica.",
"duration_minutes": 15
},
{
"step": 2,
"title": "Primera Fermentación",
"description": "Dejar reposar la masa en un recipiente tapado durante 60 minutos a temperatura ambiente (22-24°C).",
"duration_minutes": 60
},
{
"step": 3,
"title": "División y Formado",
"description": "Dividir la masa en 10 piezas de 250g cada una. Formar las baguettes dándoles la forma alargada característica.",
"duration_minutes": 20
},
{
"step": 4,
"title": "Segunda Fermentación",
"description": "Colocar las baguettes en un lienzo enharinado y dejar fermentar 60 minutos más.",
"duration_minutes": 60
},
{
"step": 5,
"title": "Greñado y Horneado",
"description": "Hacer cortes diagonales en la superficie con una cuchilla. Hornear a 240°C con vapor inicial durante 25 minutos.",
"duration_minutes": 25
}
]
},
"preparation_notes": "Es crucial usar vapor al inicio del horneado para lograr una corteza crujiente. La temperatura del agua debe estar entre 18-20°C.",
"storage_instructions": "Consumir el mismo día de producción. Se puede congelar después del horneado.",
"quality_standards": "Color dorado uniforme, corteza muy crujiente, miga alveolada con alveolos irregulares, aroma característico a trigo.",
"is_seasonal": false,
"is_signature_item": true,
"ingredientes": [
{
"ingredient_id": "10000000-0000-0000-0000-000000000001",
"ingredient_sku": "HAR-T55-001",
"quantity": 1000.0,
"unit": "g",
"preparation_method": "tamizada",
"ingredient_order": 1,
"ingredient_group": "Secos"
},
{
"ingredient_id": "10000000-0000-0000-0000-000000000033",
"ingredient_sku": "BAS-AGU-003",
"quantity": 650.0,
"unit": "ml",
"preparation_method": "temperatura ambiente",
"ingredient_order": 2,
"ingredient_group": "Líquidos"
},
{
"ingredient_id": "10000000-0000-0000-0000-000000000031",
"ingredient_sku": "BAS-SAL-001",
"quantity": 20.0,
"unit": "g",
"ingredient_order": 3,
"ingredient_group": "Secos"
},
{
"ingredient_id": "10000000-0000-0000-0000-000000000021",
"ingredient_sku": "LEV-FRE-001",
"quantity": 15.0,
"unit": "g",
"preparation_method": "desmenuzada",
"ingredient_order": 4,
"ingredient_group": "Fermentos"
}
]
},
{
"id": "30000000-0000-0000-0000-000000000002",
"finished_product_id": "20000000-0000-0000-0000-000000000002",
"name": "Croissant de Mantequilla Artesanal",
"category": "Bollería",
"cuisine_type": "Francesa",
"difficulty_level": 4,
"yield_quantity": 12.0,
"yield_unit": "units",
"prep_time_minutes": 45,
"cook_time_minutes": 18,
"total_time_minutes": 333,
"rest_time_minutes": 270,
"description": "Croissant de mantequilla con laminado perfecto y textura hojaldrada. Elaboración artesanal con mantequilla de alta calidad.",
"instructions": {
"steps": [
{
"step": 1,
"title": "Preparación de la Masa Base",
"description": "Mezclar todos los ingredientes excepto la mantequilla de laminado. Amasar hasta obtener una masa homogénea.",
"duration_minutes": 20
},
{
"step": 2,
"title": "Reposo en Frío",
"description": "Envolver la masa en film y refrigerar durante 2 horas.",
"duration_minutes": 120
},
{
"step": 3,
"title": "Laminado",
"description": "Extender la masa en rectángulo. Colocar la mantequilla en el centro y hacer 3 dobleces sencillos con 30 minutos de reposo entre cada uno.",
"duration_minutes": 90
},
{
"step": 4,
"title": "Formado",
"description": "Extender a 3mm de grosor, cortar triángulos y enrollar para formar los croissants.",
"duration_minutes": 25
},
{
"step": 5,
"title": "Fermentación Final",
"description": "Dejar fermentar a 26°C durante 2-3 horas hasta que dupliquen su volumen.",
"duration_minutes": 150
},
{
"step": 6,
"title": "Horneado",
"description": "Pintar con huevo batido y hornear a 200°C durante 18 minutos hasta dorar.",
"duration_minutes": 18
}
]
},
"preparation_notes": "La mantequilla para laminar debe estar a 15-16°C, flexible pero no blanda. Trabajar en ambiente fresco.",
"storage_instructions": "Consumir el día de producción. Se puede congelar la masa formada antes de la fermentación final.",
"quality_standards": "Laminado perfecto con capas visibles, color marrón brillante, estructura hojaldrada bien definida, aroma intenso a mantequilla.",
"is_seasonal": false,
"is_signature_item": true,
"ingredientes": [
{
"ingredient_sku": "HAR-T55-001",
"quantity": 500.0,
"unit": "g",
"ingredient_order": 1,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000001"
},
{
"ingredient_sku": "LAC-LEC-002",
"quantity": 120.0,
"unit": "ml",
"preparation_method": "tibia",
"ingredient_order": 2,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000012"
},
{
"ingredient_sku": "BAS-AGU-003",
"quantity": 80.0,
"unit": "ml",
"ingredient_order": 3,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000033"
},
{
"ingredient_sku": "BAS-AZU-002",
"quantity": 50.0,
"unit": "g",
"ingredient_order": 4,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000032"
},
{
"ingredient_sku": "BAS-SAL-001",
"quantity": 10.0,
"unit": "g",
"ingredient_order": 5,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000031"
},
{
"ingredient_sku": "LEV-FRE-001",
"quantity": 20.0,
"unit": "g",
"ingredient_order": 6,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000021"
},
{
"ingredient_sku": "LAC-MAN-001",
"quantity": 25.0,
"unit": "g",
"preparation_method": "en la masa",
"ingredient_order": 7,
"ingredient_group": "Masa base",
"ingredient_id": "10000000-0000-0000-0000-000000000011"
},
{
"ingredient_sku": "LAC-MAN-001",
"quantity": 250.0,
"unit": "g",
"preparation_method": "para laminar (15-16°C)",
"ingredient_order": 8,
"ingredient_group": "Laminado",
"ingredient_id": "10000000-0000-0000-0000-000000000011"
}
]
},
{
"name": "Pan de Pueblo con Masa Madre",
"category": "Panes Artesanales",
"cuisine_type": "Española",
"difficulty_level": 3,
"yield_quantity": 4.0,
"yield_unit": "units",
"prep_time_minutes": 30,
"cook_time_minutes": 45,
"total_time_minutes": 435,
"rest_time_minutes": 360,
"description": "Hogaza de pan rústico elaborada con masa madre natural. Corteza gruesa y miga densa con sabor ligeramente ácido.",
"instructions": {
"steps": [
{
"step": 1,
"title": "Autolisis",
"description": "Mezclar harinas y agua, dejar reposar 30 minutos para desarrollar el gluten.",
"duration_minutes": 30
},
{
"step": 2,
"title": "Incorporación de Masa Madre y Sal",
"description": "Añadir la masa madre y la sal. Amasar suavemente hasta integrar completamente.",
"duration_minutes": 15
},
{
"step": 3,
"title": "Fermentación en Bloque con Pliegues",
"description": "Realizar 4 series de pliegues cada 30 minutos durante las primeras 2 horas. Luego dejar reposar 2 horas más.",
"duration_minutes": 240
},
{
"step": 4,
"title": "División y Preformado",
"description": "Dividir en 4 piezas de 800g. Preformar en bolas y dejar reposar 30 minutos.",
"duration_minutes": 30
},
{
"step": 5,
"title": "Formado Final",
"description": "Formar las hogazas dándoles tensión superficial. Colocar en banneton o lienzo enharinado.",
"duration_minutes": 15
},
{
"step": 6,
"title": "Fermentación Final",
"description": "Dejar fermentar a temperatura ambiente durante 2 horas o en frío durante la noche.",
"duration_minutes": 120
},
{
"step": 7,
"title": "Horneado",
"description": "Hacer cortes en la superficie. Hornear a 230°C con vapor inicial durante 45 minutos.",
"duration_minutes": 45
}
]
},
"preparation_notes": "La masa madre debe estar activa y en su punto óptimo. La temperatura final de la masa debe ser 24-25°C.",
"storage_instructions": "Se conserva hasta 5-7 días en bolsa de papel. Mejora al segundo día.",
"quality_standards": "Corteza gruesa y oscura, miga densa pero húmeda, alveolos irregulares, sabor complejo ligeramente ácido.",
"is_seasonal": false,
"is_signature_item": true,
"ingredientes": [
{
"ingredient_sku": "HAR-T65-002",
"quantity": 800.0,
"unit": "g",
"ingredient_order": 1,
"ingredient_group": "Harinas",
"ingredient_id": "10000000-0000-0000-0000-000000000002"
},
{
"ingredient_sku": "HAR-INT-004",
"quantity": 200.0,
"unit": "g",
"ingredient_order": 2,
"ingredient_group": "Harinas",
"ingredient_id": "10000000-0000-0000-0000-000000000004"
},
{
"ingredient_sku": "LEV-MAD-003",
"quantity": 300.0,
"unit": "g",
"preparation_method": "activa y alimentada",
"ingredient_order": 3,
"ingredient_group": "Fermentos",
"ingredient_id": "10000000-0000-0000-0000-000000000023"
},
{
"ingredient_sku": "BAS-AGU-003",
"quantity": 650.0,
"unit": "ml",
"preparation_method": "temperatura ambiente",
"ingredient_order": 4,
"ingredient_group": "Líquidos",
"ingredient_id": "10000000-0000-0000-0000-000000000033"
},
{
"ingredient_sku": "BAS-SAL-001",
"quantity": 22.0,
"unit": "g",
"ingredient_order": 5,
"ingredient_group": "Condimentos",
"ingredient_id": "10000000-0000-0000-0000-000000000031"
}
],
"id": "30000000-0000-0000-0000-000000000003",
"finished_product_id": "20000000-0000-0000-0000-000000000003"
},
{
"name": "Napolitana de Chocolate",
"category": "Bollería",
"cuisine_type": "Española",
"difficulty_level": 3,
"yield_quantity": 16.0,
"yield_unit": "units",
"prep_time_minutes": 40,
"cook_time_minutes": 15,
"total_time_minutes": 325,
"rest_time_minutes": 270,
"description": "Bollería de hojaldre rectangular rellena de chocolate. Clásico de las panaderías españolas.",
"instructions": {
"steps": [
{
"step": 1,
"title": "Masa Base y Laminado",
"description": "Preparar masa de hojaldre siguiendo el mismo proceso que los croissants.",
"duration_minutes": 180
},
{
"step": 2,
"title": "Corte y Formado",
"description": "Extender la masa y cortar rectángulos de 10x15cm. Colocar barritas de chocolate en el centro.",
"duration_minutes": 20
},
{
"step": 3,
"title": "Sellado",
"description": "Doblar la masa sobre sí misma para cubrir el chocolate. Sellar bien los bordes.",
"duration_minutes": 20
},
{
"step": 4,
"title": "Fermentación",
"description": "Dejar fermentar a 26°C durante 90 minutos.",
"duration_minutes": 90
},
{
"step": 5,
"title": "Horneado",
"description": "Pintar con huevo y hornear a 190°C durante 15 minutos.",
"duration_minutes": 15
}
]
},
"preparation_notes": "El chocolate debe ser de buena calidad para un mejor resultado. No sobrecargar de chocolate.",
"storage_instructions": "Consumir preferiblemente el día de producción.",
"quality_standards": "Hojaldre bien desarrollado, chocolate fundido en el interior, color dorado brillante.",
"is_seasonal": false,
"is_signature_item": false,
"ingredientes": [
{
"ingredient_sku": "HAR-T55-001",
"quantity": 500.0,
"unit": "g",
"ingredient_order": 1,
"ingredient_group": "Masa",
"ingredient_id": "10000000-0000-0000-0000-000000000001"
},
{
"ingredient_sku": "LAC-MAN-001",
"quantity": 300.0,
"unit": "g",
"ingredient_order": 2,
"ingredient_group": "Laminado",
"ingredient_id": "10000000-0000-0000-0000-000000000011"
},
{
"ingredient_sku": "ESP-CHO-001",
"quantity": 200.0,
"unit": "g",
"preparation_method": "en barritas",
"ingredient_order": 3,
"ingredient_group": "Relleno",
"ingredient_id": "10000000-0000-0000-0000-000000000041"
},
{
"ingredient_sku": "BAS-AZU-002",
"quantity": 60.0,
"unit": "g",
"ingredient_order": 4,
"ingredient_group": "Masa",
"ingredient_id": "10000000-0000-0000-0000-000000000032"
},
{
"ingredient_sku": "BAS-SAL-001",
"quantity": 10.0,
"unit": "g",
"ingredient_order": 5,
"ingredient_group": "Masa",
"ingredient_id": "10000000-0000-0000-0000-000000000031"
},
{
"ingredient_sku": "LEV-FRE-001",
"quantity": 15.0,
"unit": "g",
"ingredient_order": 6,
"ingredient_group": "Masa",
"ingredient_id": "10000000-0000-0000-0000-000000000021"
},
{
"ingredient_sku": "LAC-LEC-002",
"quantity": 150.0,
"unit": "ml",
"ingredient_order": 7,
"ingredient_group": "Masa",
"ingredient_id": "10000000-0000-0000-0000-000000000012"
}
],
"id": "30000000-0000-0000-0000-000000000004",
"finished_product_id": "20000000-0000-0000-0000-000000000004"
}
]
}

387
services/recipes/scripts/demo/seed_demo_recipes.py Executable file
View File

@@ -0,0 +1,387 @@
#!/usr/bin/env python3
"""
Demo Recipes Seeding Script for Recipes Service
Creates realistic Spanish recipes for demo template tenants
This script runs as a Kubernetes init job inside the recipes-service container.
It populates the template tenants with a comprehensive catalog of recipes using pre-defined UUIDs.
Usage:
python /app/scripts/demo/seed_demo_recipes.py
Environment Variables Required:
RECIPES_DATABASE_URL - PostgreSQL connection string for recipes database
DEMO_MODE - Set to 'production' for production seeding
LOG_LEVEL - Logging level (default: INFO)
"""
import asyncio
import uuid
import sys
import os
import json
from datetime import datetime, timezone, timedelta
from pathlib import Path
import random
# Add app to path
sys.path.insert(0, str(Path(__file__).parent.parent.parent))
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy import select
import structlog
from app.models.recipes import (
Recipe, RecipeIngredient, ProductionBatch,
RecipeStatus, ProductionStatus, ProductionPriority, MeasurementUnit
)
# Configure logging
structlog.configure(
processors=[
structlog.stdlib.add_log_level,
structlog.processors.TimeStamper(fmt="iso"),
structlog.dev.ConsoleRenderer()
]
)
logger = structlog.get_logger()
# Fixed Demo Tenant IDs (must match tenant service)
DEMO_TENANT_SAN_PABLO = uuid.UUID("a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6")
DEMO_TENANT_LA_ESPIGA = uuid.UUID("b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7")
def load_recipes_data():
"""Load recipes data from JSON file"""
# Look for data file in the same directory as this script
data_file = Path(__file__).parent / "recetas_es.json"
if not data_file.exists():
raise FileNotFoundError(
f"Recipes data file not found: {data_file}. "
"Make sure recetas_es.json is in the same directory as this script."
)
logger.info("Loading recipes data", file=str(data_file))
with open(data_file, 'r', encoding='utf-8') as f:
data = json.load(f)
recipes = data.get("recetas", [])
logger.info(f"Loaded {len(recipes)} recipes from JSON")
return recipes
async def seed_recipes_for_tenant(
db: AsyncSession,
tenant_id: uuid.UUID,
tenant_name: str,
recipes_data: list
) -> dict:
"""
Seed recipes for a specific tenant using pre-defined UUIDs
Args:
db: Database session
tenant_id: UUID of the tenant
tenant_name: Name of the tenant (for logging)
recipes_data: List of recipe dictionaries with pre-defined IDs
Returns:
Dict with seeding statistics
"""
logger.info("─" * 80)
logger.info(f"Seeding recipes for: {tenant_name}")
logger.info(f"Tenant ID: {tenant_id}")
logger.info("─" * 80)
created_recipes = 0
skipped_recipes = 0
created_ingredients = 0
created_batches = 0
for recipe_data in recipes_data:
recipe_name = recipe_data["name"]
# Generate tenant-specific UUIDs (same approach as inventory)
base_recipe_id = uuid.UUID(recipe_data["id"])
base_product_id = uuid.UUID(recipe_data["finished_product_id"])
tenant_int = int(tenant_id.hex, 16)
recipe_id = uuid.UUID(int=tenant_int ^ int(base_recipe_id.hex, 16))
finished_product_id = uuid.UUID(int=tenant_int ^ int(base_product_id.hex, 16))
# Check if recipe already exists
result = await db.execute(
select(Recipe).where(
Recipe.tenant_id == tenant_id,
Recipe.id == recipe_id
)
)
existing_recipe = result.scalars().first()
if existing_recipe:
logger.debug(f" ⏭️ Skipping recipe (exists): {recipe_name}")
skipped_recipes += 1
continue
# Create recipe using pre-defined UUID
recipe = Recipe(
id=recipe_id,
tenant_id=tenant_id,
name=recipe_name,
recipe_code=f"REC-{created_recipes + 1:03d}",
version="1.0",
finished_product_id=finished_product_id,
description=recipe_data.get("description"),
category=recipe_data.get("category"),
cuisine_type=recipe_data.get("cuisine_type"),
difficulty_level=recipe_data.get("difficulty_level", 1),
yield_quantity=recipe_data.get("yield_quantity"),
yield_unit=MeasurementUnit(recipe_data.get("yield_unit", "units")),
prep_time_minutes=recipe_data.get("prep_time_minutes"),
cook_time_minutes=recipe_data.get("cook_time_minutes"),
total_time_minutes=recipe_data.get("total_time_minutes"),
rest_time_minutes=recipe_data.get("rest_time_minutes"),
instructions=recipe_data.get("instructions"),
preparation_notes=recipe_data.get("preparation_notes"),
storage_instructions=recipe_data.get("storage_instructions"),
quality_standards=recipe_data.get("quality_standards"),
status=RecipeStatus.ACTIVE,
is_seasonal=recipe_data.get("is_seasonal", False),
is_signature_item=recipe_data.get("is_signature_item", False),
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc)
)
db.add(recipe)
created_recipes += 1
logger.debug(f" ✅ Created recipe: {recipe_name}")
# Create recipe ingredients using tenant-specific ingredient IDs
for ing_data in recipe_data.get("ingredientes", []):
base_ingredient_id = uuid.UUID(ing_data["ingredient_id"])
ingredient_id = uuid.UUID(int=tenant_int ^ int(base_ingredient_id.hex, 16))
# Parse unit
unit_str = ing_data.get("unit", "g")
try:
unit = MeasurementUnit(unit_str)
except ValueError:
logger.warning(f" ⚠️ Invalid unit: {unit_str}, using GRAMS")
unit = MeasurementUnit.GRAMS
recipe_ingredient = RecipeIngredient(
id=uuid.uuid4(),
tenant_id=tenant_id,
recipe_id=recipe_id,
ingredient_id=ingredient_id,
quantity=ing_data["quantity"],
unit=unit,
preparation_method=ing_data.get("preparation_method"),
ingredient_order=ing_data.get("ingredient_order", 1),
ingredient_group=ing_data.get("ingredient_group")
)
db.add(recipe_ingredient)
created_ingredients += 1
# Create some sample production batches (historical data)
num_batches = random.randint(3, 8)
for i in range(num_batches):
# Random date in the past 30 days
days_ago = random.randint(1, 30)
production_date = datetime.now(timezone.utc) - timedelta(days=days_ago)
# Random multiplier and quantity
multiplier = random.choice([0.5, 1.0, 1.5, 2.0])
planned_qty = recipe_data.get("yield_quantity", 10) * multiplier
actual_qty = planned_qty * random.uniform(0.95, 1.05)
batch = ProductionBatch(
id=uuid.uuid4(),
tenant_id=tenant_id,
recipe_id=recipe_id,
batch_number=f"BATCH-{tenant_id.hex[:8].upper()}-{i+1:04d}",
production_date=production_date,
planned_quantity=planned_qty,
actual_quantity=actual_qty,
yield_percentage=(actual_qty / planned_qty * 100) if planned_qty > 0 else 100,
batch_size_multiplier=multiplier,
status=ProductionStatus.COMPLETED,
priority=ProductionPriority.NORMAL,
quality_score=random.uniform(7.5, 9.5),
created_at=production_date,
updated_at=production_date
)
db.add(batch)
created_batches += 1
# Commit all changes for this tenant
await db.commit()
logger.info(f" 📊 Recipes: {created_recipes}, Ingredients: {created_ingredients}, Batches: {created_batches}")
logger.info("")
return {
"tenant_id": str(tenant_id),
"tenant_name": tenant_name,
"recipes_created": created_recipes,
"recipes_skipped": skipped_recipes,
"recipe_ingredients_created": created_ingredients,
"production_batches_created": created_batches,
"total_recipes": len(recipes_data)
}
async def seed_recipes(db: AsyncSession):
"""
Seed recipes for all demo template tenants
Args:
db: Database session
Returns:
Dict with overall seeding statistics
"""
logger.info("=" * 80)
logger.info("📚 Starting Demo Recipes Seeding")
logger.info("=" * 80)
# Load recipes data once
try:
recipes_data = load_recipes_data()
except FileNotFoundError as e:
logger.error(str(e))
raise
results = []
# Seed for San Pablo (Traditional Bakery)
logger.info("")
result_san_pablo = await seed_recipes_for_tenant(
db,
DEMO_TENANT_SAN_PABLO,
"Panadería San Pablo (Traditional)",
recipes_data
)
results.append(result_san_pablo)
# Seed for La Espiga (Central Workshop)
result_la_espiga = await seed_recipes_for_tenant(
db,
DEMO_TENANT_LA_ESPIGA,
"Panadería La Espiga (Central Workshop)",
recipes_data
)
results.append(result_la_espiga)
# Calculate totals
total_recipes = sum(r["recipes_created"] for r in results)
total_ingredients = sum(r["recipe_ingredients_created"] for r in results)
total_batches = sum(r["production_batches_created"] for r in results)
total_skipped = sum(r["recipes_skipped"] for r in results)
logger.info("=" * 80)
logger.info("✅ Demo Recipes Seeding Completed")
logger.info("=" * 80)
return {
"service": "recipes",
"tenants_seeded": len(results),
"total_recipes_created": total_recipes,
"total_recipe_ingredients_created": total_ingredients,
"total_production_batches_created": total_batches,
"total_skipped": total_skipped,
"results": results
}
async def main():
"""Main execution function"""
logger.info("Demo Recipes Seeding Script Starting")
logger.info("Mode: %s", os.getenv("DEMO_MODE", "development"))
logger.info("Log Level: %s", os.getenv("LOG_LEVEL", "INFO"))
# Get database URLs from environment
database_url = os.getenv("RECIPES_DATABASE_URL") or os.getenv("DATABASE_URL")
if not database_url:
logger.error("❌ RECIPES_DATABASE_URL or DATABASE_URL environment variable must be set")
return 1
# Convert to async URL if needed
if database_url.startswith("postgresql://"):
database_url = database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
logger.info("Connecting to recipes database")
# Create engine and session
engine = create_async_engine(
database_url,
echo=False,
pool_pre_ping=True,
pool_size=5,
max_overflow=10
)
session_maker = sessionmaker(
engine,
class_=AsyncSession,
expire_on_commit=False
)
try:
async with session_maker() as session:
result = await seed_recipes(session)
logger.info("")
logger.info("📊 Seeding Summary:")
logger.info(f" ✅ Tenants seeded: {result['tenants_seeded']}")
logger.info(f" ✅ Recipes created: {result['total_recipes_created']}")
logger.info(f" ✅ Recipe ingredients: {result['total_recipe_ingredients_created']}")
logger.info(f" ✅ Production batches: {result['total_production_batches_created']}")
logger.info(f" ⏭️ Skipped: {result['total_skipped']}")
logger.info("")
# Print per-tenant details
for tenant_result in result['results']:
logger.info(
f" {tenant_result['tenant_name']}: "
f"{tenant_result['recipes_created']} recipes, "
f"{tenant_result['recipe_ingredients_created']} ingredients, "
f"{tenant_result['production_batches_created']} batches"
)
logger.info("")
logger.info("🎉 Success! Recipe catalog is ready for cloning.")
logger.info("")
logger.info("Recipes created:")
logger.info(" • Baguette Francesa Tradicional")
logger.info(" • Croissant de Mantequilla Artesanal")
logger.info(" • Pan de Pueblo con Masa Madre")
logger.info(" • Napolitana de Chocolate")
logger.info("")
logger.info("Note: All IDs are pre-defined and hardcoded for cross-service consistency")
logger.info("")
return 0
except Exception as e:
logger.error("=" * 80)
logger.error("❌ Demo Recipes Seeding Failed")
logger.error("=" * 80)
logger.error("Error: %s", str(e))
logger.error("", exc_info=True)
return 1
finally:
await engine.dispose()
if __name__ == "__main__":
exit_code = asyncio.run(main())
sys.exit(exit_code)