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

refactor(demo): Standardize demo account type names across codebase

Browse Source 
Standardize demo account type naming from inconsistent variants to clean names:
- individual_bakery, professional_bakery → professional
- central_baker, enterprise_chain → enterprise

This eliminates naming confusion that was causing bugs in the demo session
initialization, particularly for enterprise demo tenants where different
parts of the system used different names for the same concept.

Changes:
- Updated source of truth in demo_session config
- Updated all backend services (middleware, cloning, orchestration)
- Updated frontend types, pages, and stores
- Updated demo session models and schemas
- Removed all backward compatibility code as requested

Related to: Enterprise demo session access fix

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Urtzi Alfaro
2025-11-30 08:48:56 +01:00
parent 2d9fc01515
commit fd657dea02
13 changed files with 2186 additions and 650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

387
services/tenant/app/api/internal_demo.py
View File

@@ -13,22 +13,21 @@ from typing import Optional
import os
from app.core.database import get_db
from app.models.tenants import Tenant
from app.models.tenants import Tenant, Subscription, TenantMember
from app.models.tenant_location import TenantLocation
from app.core.config import settings
logger = structlog.get_logger()
router = APIRouter(prefix="/internal/demo", tags=["internal"])
# Internal API key for service-to-service auth
INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "dev-internal-key-change-in-production")
# Base demo tenant IDs
DEMO_TENANT_SAN_PABLO = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
DEMO_TENANT_LA_ESPIGA = "b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7"
DEMO_TENANT_PROFESSIONAL = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
def verify_internal_api_key(x_internal_api_key: Optional[str] = Header(None)):
"""Verify internal API key for service-to-service communication"""
if x_internal_api_key != INTERNAL_API_KEY:
if x_internal_api_key != settings.INTERNAL_API_KEY:
logger.warning("Unauthorized internal API access attempted")
raise HTTPException(status_code=403, detail="Invalid internal API key")
return True
@@ -86,7 +85,6 @@ async def clone_demo_data(
)
# Ensure the tenant has a subscription (copy from template if missing)
from app.models.tenants import Subscription
from datetime import timedelta
result = await db.execute(
@@ -155,10 +153,10 @@ async def clone_demo_data(
# Note: Use the actual demo user IDs from seed_demo_users.py
# These match the demo users created in the auth service
DEMO_OWNER_IDS = {
"individual_bakery": "c1a2b3c4-d5e6-47a8-b9c0-d1e2f3a4b5c6", # María García López (San Pablo)
"central_baker": "d2e3f4a5-b6c7-48d9-e0f1-a2b3c4d5e6f7" # Carlos Martínez Ruiz (La Espiga)
"professional": "c1a2b3c4-d5e6-47a8-b9c0-d1e2f3a4b5c6", # María García López
"enterprise": "d2e3f4a5-b6c7-48d9-e0f1-a2b3c4d5e6f7" # Carlos Martínez Ruiz
}
demo_owner_uuid = uuid.UUID(DEMO_OWNER_IDS.get(demo_account_type, DEMO_OWNER_IDS["individual_bakery"]))
demo_owner_uuid = uuid.UUID(DEMO_OWNER_IDS.get(demo_account_type, DEMO_OWNER_IDS["professional"]))
tenant = Tenant(
id=virtual_uuid,
@@ -169,6 +167,7 @@ async def clone_demo_data(
business_type="bakery",
is_demo=True,
is_demo_template=False,
demo_session_id=session_id, # Link tenant to demo session
business_model=demo_account_type,
is_active=True,
timezone="Europe/Madrid",
@@ -178,23 +177,36 @@ async def clone_demo_data(
db.add(tenant)
await db.flush() # Flush to get the tenant ID
# Create demo subscription (enterprise tier for full access)
from app.models.tenants import Subscription
# Create demo subscription with appropriate tier based on demo account type
# Determine subscription tier based on demo account type
if demo_account_type == "professional":
plan = "professional"
max_locations = 3
elif demo_account_type in ["enterprise", "enterprise_parent"]:
plan = "enterprise"
max_locations = -1 # Unlimited
elif demo_account_type == "enterprise_child":
plan = "enterprise"
max_locations = 1
else:
plan = "starter"
max_locations = 1
demo_subscription = Subscription(
tenant_id=tenant.id,
plan="enterprise", # Demo gets full access
plan=plan, # Set appropriate tier based on demo account type
status="active",
monthly_price=0.0, # Free for demo
billing_cycle="monthly",
max_users=-1, # Unlimited
max_locations=-1,
max_products=-1,
max_users=-1, # Unlimited for demo
max_locations=max_locations,
max_products=-1, # Unlimited for demo
features={}
)
db.add(demo_subscription)
# Create tenant member records for demo owner and staff
from app.models.tenants import TenantMember
import json
# Helper function to get permissions for role
@@ -218,7 +230,7 @@ async def clone_demo_data(
# Define staff users for each demo account type (must match seed_demo_tenant_members.py)
STAFF_USERS = {
"individual_bakery": [
"professional": [
# Owner
{
"user_id": uuid.UUID("c1a2b3c4-d5e6-47a8-b9c0-d1e2f3a4b5c6"),
@@ -250,7 +262,7 @@ async def clone_demo_data(
"role": "production_manager"
}
],
"central_baker": [
"enterprise": [
# Owner
{
"user_id": uuid.UUID("d2e3f4a5-b6c7-48d9-e0f1-a2b3c4d5e6f7"),
@@ -310,50 +322,45 @@ async def clone_demo_data(
members_created=members_created
)
# Clone subscription from template tenant
from app.models.tenants import Subscription
from datetime import timedelta
# Clone TenantLocations
from app.models.tenant_location import TenantLocation
# Get subscription from template tenant
base_uuid = uuid.UUID(base_tenant_id)
result = await db.execute(
select(Subscription).where(
Subscription.tenant_id == base_uuid,
Subscription.status == "active"
)
location_result = await db.execute(
select(TenantLocation).where(TenantLocation.tenant_id == base_uuid)
)
template_subscription = result.scalars().first()
base_locations = location_result.scalars().all()
subscription_plan = "unknown"
if template_subscription:
# Clone subscription from template
subscription = Subscription(
tenant_id=virtual_uuid,
plan=template_subscription.plan,
status=template_subscription.status,
monthly_price=template_subscription.monthly_price,
max_users=template_subscription.max_users,
max_locations=template_subscription.max_locations,
max_products=template_subscription.max_products,
features=template_subscription.features.copy() if template_subscription.features else {},
trial_ends_at=template_subscription.trial_ends_at,
next_billing_date=datetime.now(timezone.utc) + timedelta(days=90) if template_subscription.next_billing_date else None
records_cloned = 1 + members_created # Tenant + TenantMembers
for base_location in base_locations:
virtual_location = TenantLocation(
id=uuid.uuid4(),
tenant_id=virtual_tenant_id,
name=base_location.name,
location_type=base_location.location_type,
address=base_location.address,
city=base_location.city,
postal_code=base_location.postal_code,
latitude=base_location.latitude,
longitude=base_location.longitude,
capacity=base_location.capacity,
delivery_windows=base_location.delivery_windows,
operational_hours=base_location.operational_hours,
max_delivery_radius_km=base_location.max_delivery_radius_km,
delivery_schedule_config=base_location.delivery_schedule_config,
is_active=base_location.is_active,
contact_person=base_location.contact_person,
contact_phone=base_location.contact_phone,
contact_email=base_location.contact_email,
metadata_=base_location.metadata_ if isinstance(base_location.metadata_, dict) else (base_location.metadata_ or {})
)
db.add(virtual_location)
records_cloned += 1
db.add(subscription)
subscription_plan = subscription.plan
logger.info("Cloned TenantLocations", count=len(base_locations))
logger.info(
"Cloning subscription from template tenant",
template_tenant_id=base_tenant_id,
virtual_tenant_id=virtual_tenant_id,
plan=subscription_plan
)
else:
logger.warning(
"No subscription found on template tenant - virtual tenant will have no subscription",
base_tenant_id=base_tenant_id
)
# Subscription already created earlier based on demo_account_type (lines 179-206)
# No need to clone from template - this prevents duplicate subscription creation
await db.commit()
await db.refresh(tenant)
@@ -361,16 +368,14 @@ async def clone_demo_data(
duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
logger.info(
"Virtual tenant created successfully with cloned subscription",
"Virtual tenant created successfully with subscription",
virtual_tenant_id=virtual_tenant_id,
tenant_name=tenant.name,
subscription_plan=subscription_plan,
subscription_plan=plan,
duration_ms=duration_ms
)
records_cloned = 1 + members_created # Tenant + TenantMembers
if template_subscription:
records_cloned += 1 # Subscription
records_cloned = 1 + members_created + 1 # Tenant + TenantMembers + Subscription
return {
"service": "tenant",
@@ -383,8 +388,8 @@ async def clone_demo_data(
"business_model": tenant.business_model,
"owner_id": str(demo_owner_uuid),
"members_created": members_created,
"subscription_plan": subscription_plan,
"subscription_cloned": template_subscription is not None
"subscription_plan": plan,
"subscription_created": True
}
}
@@ -412,6 +417,260 @@ async def clone_demo_data(
}
@router.post("/create-child")
async def create_child_outlet(
request: dict,
db: AsyncSession = Depends(get_db),
_: bool = Depends(verify_internal_api_key)
):
"""
Create a child outlet tenant for enterprise demos
Args:
request: JSON request body with child tenant details
Returns:
Creation status and tenant details
"""
# Extract parameters from request body
base_tenant_id = request.get("base_tenant_id")
virtual_tenant_id = request.get("virtual_tenant_id")
parent_tenant_id = request.get("parent_tenant_id")
child_name = request.get("child_name")
location = request.get("location", {})
session_id = request.get("session_id")
start_time = datetime.now(timezone.utc)
logger.info(
"Creating child outlet tenant",
virtual_tenant_id=virtual_tenant_id,
parent_tenant_id=parent_tenant_id,
child_name=child_name,
session_id=session_id
)
try:
# Validate UUIDs
virtual_uuid = uuid.UUID(virtual_tenant_id)
parent_uuid = uuid.UUID(parent_tenant_id)
# Check if child tenant already exists
result = await db.execute(select(Tenant).where(Tenant.id == virtual_uuid))
existing_tenant = result.scalars().first()
if existing_tenant:
logger.info(
"Child tenant already exists",
virtual_tenant_id=virtual_tenant_id,
tenant_name=existing_tenant.name
)
# Return existing tenant - idempotent operation
duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
return {
"service": "tenant",
"status": "completed",
"records_created": 0,
"duration_ms": duration_ms,
"details": {
"tenant_id": str(virtual_uuid),
"tenant_name": existing_tenant.name,
"already_exists": True
}
}
# Create child tenant with parent relationship
child_tenant = Tenant(
id=virtual_uuid,
name=child_name,
address=location.get("address", f"Calle Outlet {location.get('city', 'Madrid')}"),
city=location.get("city", "Madrid"),
postal_code=location.get("postal_code", "28001"),
business_type="bakery",
is_demo=True,
is_demo_template=False,
demo_session_id=session_id, # Link child tenant to demo session
business_model="retail_outlet",
is_active=True,
timezone="Europe/Madrid",
# Set parent relationship
parent_tenant_id=parent_uuid,
tenant_type="child",
hierarchy_path=f"{str(parent_uuid)}.{str(virtual_uuid)}",
# Owner ID - using demo owner ID from parent
# In real implementation, this would be the same owner as the parent tenant
owner_id=uuid.UUID("c1a2b3c4-d5e6-47a8-b9c0-d1e2f3a4b5c6") # Demo owner ID
)
db.add(child_tenant)
await db.flush() # Flush to get the tenant ID
# Create TenantLocation for this retail outlet
child_location = TenantLocation(
id=uuid.uuid4(),
tenant_id=virtual_uuid,
name=f"{child_name} - Retail Outlet",
location_type="retail_outlet",
address=location.get("address", f"Calle Outlet {location.get('city', 'Madrid')}"),
city=location.get("city", "Madrid"),
postal_code=location.get("postal_code", "28001"),
latitude=location.get("latitude"),
longitude=location.get("longitude"),
delivery_windows={
"monday": "07:00-10:00",
"wednesday": "07:00-10:00",
"friday": "07:00-10:00"
},
operational_hours={
"monday": "07:00-21:00",
"tuesday": "07:00-21:00",
"wednesday": "07:00-21:00",
"thursday": "07:00-21:00",
"friday": "07:00-21:00",
"saturday": "08:00-21:00",
"sunday": "09:00-21:00"
},
delivery_schedule_config={
"delivery_days": ["monday", "wednesday", "friday"],
"time_window": "07:00-10:00"
},
is_active=True
)
db.add(child_location)
logger.info("Created TenantLocation for child", child_id=str(virtual_uuid), location_name=child_location.name)
# Create parent tenant lookup to get the correct plan for the child
parent_result = await db.execute(
select(Subscription).where(
Subscription.tenant_id == parent_uuid,
Subscription.status == "active"
)
)
parent_subscription = parent_result.scalars().first()
# Child inherits the same plan as parent
parent_plan = parent_subscription.plan if parent_subscription else "enterprise"
child_subscription = Subscription(
tenant_id=child_tenant.id,
plan=parent_plan, # Child inherits the same plan as parent
status="active",
monthly_price=0.0, # Free for demo
billing_cycle="monthly",
max_users=10, # Demo limits
max_locations=1, # Single location for outlet
max_products=200,
features={}
)
db.add(child_subscription)
# Create basic tenant members like parent
import json
# Demo owner is the same as central_baker/enterprise_chain owner (not individual_bakery)
demo_owner_uuid = uuid.UUID("d2e3f4a5-b6c7-48d9-e0f1-a2b3c4d5e6f7")
# Create tenant member for owner
child_owner_member = TenantMember(
tenant_id=virtual_uuid,
user_id=demo_owner_uuid,
role="owner",
permissions=json.dumps(["read", "write", "admin", "delete"]),
is_active=True,
invited_by=demo_owner_uuid,
invited_at=datetime.now(timezone.utc),
joined_at=datetime.now(timezone.utc),
created_at=datetime.now(timezone.utc)
)
db.add(child_owner_member)
# Create some staff members for the outlet (simplified)
staff_users = [
{
"user_id": uuid.UUID("50000000-0000-0000-0000-000000000002"), # Sales user
"role": "sales"
},
{
"user_id": uuid.UUID("50000000-0000-0000-0000-000000000003"), # Quality control user
"role": "quality_control"
},
{
"user_id": uuid.UUID("50000000-0000-0000-0000-000000000005"), # Warehouse user
"role": "warehouse"
}
]
members_created = 1 # Start with owner
for staff_member in staff_users:
tenant_member = TenantMember(
tenant_id=virtual_uuid,
user_id=staff_member["user_id"],
role=staff_member["role"],
permissions=json.dumps(["read", "write"]) if staff_member["role"] != "admin" else json.dumps(["read", "write", "admin"]),
is_active=True,
invited_by=demo_owner_uuid,
invited_at=datetime.now(timezone.utc),
joined_at=datetime.now(timezone.utc),
created_at=datetime.now(timezone.utc)
)
db.add(tenant_member)
members_created += 1
await db.commit()
await db.refresh(child_tenant)
duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)
logger.info(
"Child outlet created successfully",
virtual_tenant_id=str(virtual_tenant_id),
parent_tenant_id=str(parent_tenant_id),
child_name=child_name,
duration_ms=duration_ms
)
return {
"service": "tenant",
"status": "completed",
"records_created": 2 + members_created, # Tenant + Subscription + Members
"duration_ms": duration_ms,
"details": {
"tenant_id": str(child_tenant.id),
"tenant_name": child_tenant.name,
"parent_tenant_id": str(parent_tenant_id),
"location": location,
"members_created": members_created,
"subscription_plan": "enterprise"
}
}
except ValueError as e:
logger.error("Invalid UUID format", error=str(e), virtual_tenant_id=virtual_tenant_id)
raise HTTPException(status_code=400, detail=f"Invalid UUID: {str(e)}")
except Exception as e:
logger.error(
"Failed to create child outlet",
error=str(e),
virtual_tenant_id=virtual_tenant_id,
parent_tenant_id=parent_tenant_id,
exc_info=True
)
# Rollback on error
await db.rollback()
return {
"service": "tenant",
"status": "failed",
"records_created": 0,
"duration_ms": int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000),
"error": str(e)
}
@router.get("/clone/health")
async def clone_health_check(_: bool = Depends(verify_internal_api_key)):
"""