387 lines
15 KiB
Python
387 lines
15 KiB
Python
# services/tenant/app/schemas/tenants.py
|
|
"""
|
|
Tenant schemas - FIXED VERSION
|
|
"""
|
|
|
|
from pydantic import BaseModel, Field, field_validator, ValidationInfo
|
|
from typing import Optional, List, Dict, Any
|
|
from datetime import datetime
|
|
from uuid import UUID
|
|
import re
|
|
|
|
class BakeryRegistration(BaseModel):
|
|
"""Bakery registration schema"""
|
|
name: str = Field(..., min_length=2, max_length=200)
|
|
address: str = Field(..., min_length=10, max_length=500)
|
|
city: str = Field(default="Madrid", max_length=100)
|
|
postal_code: str = Field(..., pattern=r"^\d{5}$")
|
|
phone: str = Field(..., min_length=9, max_length=20)
|
|
business_type: str = Field(default="bakery")
|
|
business_model: Optional[str] = Field(default="individual_bakery")
|
|
coupon_code: Optional[str] = Field(None, max_length=50, description="Promotional coupon code")
|
|
# Subscription linking fields (for new multi-phase registration architecture)
|
|
subscription_id: Optional[str] = Field(None, description="Existing subscription ID to link to this tenant")
|
|
link_existing_subscription: Optional[bool] = Field(False, description="Flag to link an existing subscription during tenant creation")
|
|
|
|
@field_validator('phone')
|
|
@classmethod
|
|
def validate_spanish_phone(cls, v):
|
|
"""Validate Spanish phone number"""
|
|
# Remove spaces and common separators
|
|
phone = re.sub(r'[\s\-\(\)]', '', v)
|
|
|
|
# Spanish mobile: +34 6/7/8/9 + 8 digits
|
|
# Spanish landline: +34 9 + 8 digits
|
|
patterns = [
|
|
r'^(\+34|0034|34)?[6789]\d{8}$', # Mobile
|
|
r'^(\+34|0034|34)?9\d{8}$', # Landline
|
|
]
|
|
|
|
if not any(re.match(pattern, phone) for pattern in patterns):
|
|
raise ValueError('Invalid Spanish phone number')
|
|
return v
|
|
|
|
@field_validator('business_type')
|
|
@classmethod
|
|
def validate_business_type(cls, v):
|
|
valid_types = ['bakery', 'coffee_shop', 'pastry_shop', 'restaurant']
|
|
if v not in valid_types:
|
|
raise ValueError(f'Business type must be one of: {valid_types}')
|
|
return v
|
|
|
|
@field_validator('business_model')
|
|
@classmethod
|
|
def validate_business_model(cls, v):
|
|
if v is None:
|
|
return v
|
|
valid_models = ['individual_bakery', 'central_baker_satellite', 'retail_bakery', 'hybrid_bakery']
|
|
if v not in valid_models:
|
|
raise ValueError(f'Business model must be one of: {valid_models}')
|
|
return v
|
|
|
|
class TenantResponse(BaseModel):
|
|
"""Tenant response schema - Updated to use subscription relationship"""
|
|
id: str # ✅ Keep as str for Pydantic validation
|
|
name: str
|
|
subdomain: Optional[str]
|
|
business_type: str
|
|
business_model: Optional[str]
|
|
tenant_type: Optional[str] = "standalone" # standalone, parent, or child
|
|
parent_tenant_id: Optional[str] = None # For child tenants
|
|
address: str
|
|
city: str
|
|
postal_code: str
|
|
# Regional/Localization settings
|
|
timezone: Optional[str] = "Europe/Madrid"
|
|
currency: Optional[str] = "EUR" # Currency code: EUR, USD, GBP
|
|
language: Optional[str] = "es" # Language code: es, en, eu
|
|
phone: Optional[str]
|
|
is_active: bool
|
|
subscription_plan: Optional[str] = None # Populated from subscription relationship or service
|
|
ml_model_trained: bool
|
|
last_training_date: Optional[datetime]
|
|
owner_id: str # ✅ Keep as str for Pydantic validation
|
|
created_at: datetime
|
|
|
|
# ✅ FIX: Add custom validator to convert UUID to string
|
|
@field_validator('id', 'owner_id', 'parent_tenant_id', mode='before')
|
|
@classmethod
|
|
def convert_uuid_to_string(cls, v):
|
|
"""Convert UUID objects to strings for JSON serialization"""
|
|
if isinstance(v, UUID):
|
|
return str(v)
|
|
return v
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
class TenantAccessResponse(BaseModel):
|
|
"""Tenant access verification response"""
|
|
has_access: bool
|
|
role: str
|
|
permissions: List[str]
|
|
|
|
class TenantMemberResponse(BaseModel):
|
|
"""Tenant member response - FIXED VERSION with enriched user data"""
|
|
id: str
|
|
user_id: str
|
|
role: str
|
|
is_active: bool
|
|
joined_at: Optional[datetime]
|
|
# Enriched user fields (populated via service layer)
|
|
user_email: Optional[str] = None
|
|
user_full_name: Optional[str] = None
|
|
user: Optional[Dict[str, Any]] = None # Full user object for compatibility
|
|
|
|
# ✅ FIX: Add custom validator to convert UUID to string
|
|
@field_validator('id', 'user_id', mode='before')
|
|
@classmethod
|
|
def convert_uuid_to_string(cls, v):
|
|
"""Convert UUID objects to strings for JSON serialization"""
|
|
if isinstance(v, UUID):
|
|
return str(v)
|
|
return v
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
class TenantUpdate(BaseModel):
|
|
"""Tenant update schema"""
|
|
name: Optional[str] = Field(None, min_length=2, max_length=200)
|
|
address: Optional[str] = Field(None, min_length=10, max_length=500)
|
|
phone: Optional[str] = None
|
|
business_type: Optional[str] = None
|
|
business_model: Optional[str] = None
|
|
# Regional/Localization settings
|
|
timezone: Optional[str] = None
|
|
currency: Optional[str] = Field(None, pattern=r'^(EUR|USD|GBP)$') # Currency code
|
|
language: Optional[str] = Field(None, pattern=r'^(es|en|eu)$') # Language code
|
|
|
|
class TenantListResponse(BaseModel):
|
|
"""Response schema for listing tenants"""
|
|
tenants: List[TenantResponse]
|
|
total: int
|
|
page: int
|
|
per_page: int
|
|
has_next: bool
|
|
has_prev: bool
|
|
|
|
class TenantMemberInvitation(BaseModel):
|
|
"""Schema for inviting a member to a tenant"""
|
|
email: str = Field(..., pattern=r'^[^@]+@[^@]+\.[^@]+$')
|
|
role: str = Field(..., pattern=r'^(admin|member|viewer)$')
|
|
message: Optional[str] = Field(None, max_length=500)
|
|
|
|
class TenantMemberUpdate(BaseModel):
|
|
"""Schema for updating tenant member"""
|
|
role: Optional[str] = Field(None, pattern=r'^(owner|admin|member|viewer)$')
|
|
is_active: Optional[bool] = None
|
|
|
|
class AddMemberWithUserCreate(BaseModel):
|
|
"""Schema for adding member with optional user creation (pilot phase)"""
|
|
# For existing users
|
|
user_id: Optional[str] = Field(None, description="ID of existing user to add")
|
|
|
|
# For new user creation
|
|
create_user: bool = Field(False, description="Whether to create a new user")
|
|
email: Optional[str] = Field(None, description="Email for new user (if create_user=True)")
|
|
full_name: Optional[str] = Field(None, min_length=2, max_length=100, description="Full name for new user")
|
|
password: Optional[str] = Field(None, min_length=8, max_length=128, description="Password for new user")
|
|
phone: Optional[str] = Field(None, description="Phone number for new user")
|
|
language: Optional[str] = Field("es", pattern="^(es|en|eu)$", description="Preferred language")
|
|
timezone: Optional[str] = Field("Europe/Madrid", description="User timezone")
|
|
|
|
# Common fields
|
|
role: str = Field(..., pattern=r'^(admin|member|viewer)$', description="Role in the tenant")
|
|
|
|
@field_validator('email', 'full_name', 'password')
|
|
@classmethod
|
|
def validate_user_creation_fields(cls, v, info: ValidationInfo):
|
|
"""Validate that required fields are present when creating a user"""
|
|
if info.data.get('create_user') and info.field_name in ['email', 'full_name', 'password']:
|
|
if not v:
|
|
raise ValueError(f"{info.field_name} is required when create_user is True")
|
|
return v
|
|
|
|
@field_validator('user_id')
|
|
@classmethod
|
|
def validate_user_id_or_create(cls, v, info: ValidationInfo):
|
|
"""Ensure either user_id or create_user is provided"""
|
|
if not v and not info.data.get('create_user'):
|
|
raise ValueError("Either user_id or create_user must be provided")
|
|
if v and info.data.get('create_user'):
|
|
raise ValueError("Cannot specify both user_id and create_user")
|
|
return v
|
|
|
|
class TenantSubscriptionUpdate(BaseModel):
|
|
"""Schema for updating tenant subscription"""
|
|
plan: str = Field(..., pattern=r'^(basic|professional|enterprise)$')
|
|
billing_cycle: str = Field(default="monthly", pattern=r'^(monthly|yearly)$')
|
|
|
|
class TenantStatsResponse(BaseModel):
|
|
"""Tenant statistics response"""
|
|
tenant_id: str
|
|
total_members: int
|
|
active_members: int
|
|
total_predictions: int
|
|
models_trained: int
|
|
last_training_date: Optional[datetime]
|
|
subscription_plan: str
|
|
subscription_status: str
|
|
|
|
|
|
# ============================================================================
|
|
# ENTERPRISE CHILD TENANT SCHEMAS
|
|
# ============================================================================
|
|
|
|
class ChildTenantCreate(BaseModel):
|
|
"""Schema for creating a child tenant in enterprise hierarchy - Updated to match tenant model"""
|
|
name: str = Field(..., min_length=2, max_length=200, description="Child tenant name (e.g., 'Madrid - Salamanca')")
|
|
city: str = Field(..., min_length=2, max_length=100, description="City where the outlet is located")
|
|
zone: Optional[str] = Field(None, max_length=100, description="Zone or neighborhood")
|
|
address: str = Field(..., min_length=10, max_length=500, description="Full address of the outlet")
|
|
postal_code: str = Field(..., pattern=r"^\d{5}$", description="5-digit postal code")
|
|
location_code: str = Field(..., min_length=1, max_length=10, description="Short location code (e.g., MAD, BCN)")
|
|
|
|
# Coordinates (can be geocoded from address if not provided)
|
|
latitude: Optional[float] = Field(None, ge=-90, le=90, description="Latitude coordinate")
|
|
longitude: Optional[float] = Field(None, ge=-180, le=180, description="Longitude coordinate")
|
|
|
|
# Contact info (inherits from parent if not provided)
|
|
phone: Optional[str] = Field(None, min_length=9, max_length=20, description="Contact phone")
|
|
email: Optional[str] = Field(None, description="Contact email")
|
|
|
|
# Business info
|
|
business_type: Optional[str] = Field(None, max_length=100, description="Type of business")
|
|
business_model: Optional[str] = Field(None, max_length=100, description="Business model")
|
|
|
|
# Timezone configuration
|
|
timezone: Optional[str] = Field(None, max_length=50, description="Timezone for scheduling")
|
|
|
|
# Additional metadata
|
|
metadata: Optional[Dict[str, Any]] = Field(None, description="Additional metadata for the child tenant")
|
|
|
|
@field_validator('location_code')
|
|
@classmethod
|
|
def validate_location_code(cls, v):
|
|
"""Ensure location code is uppercase and alphanumeric"""
|
|
if not v.replace('-', '').replace('_', '').isalnum():
|
|
raise ValueError('Location code must be alphanumeric (with optional hyphens/underscores)')
|
|
return v.upper()
|
|
|
|
@field_validator('phone')
|
|
@classmethod
|
|
def validate_phone(cls, v):
|
|
"""Validate Spanish phone number if provided"""
|
|
if v is None:
|
|
return v
|
|
phone = re.sub(r'[\s\-\(\)]', '', v)
|
|
patterns = [
|
|
r'^(\+34|0034|34)?[6789]\d{8}$', # Mobile
|
|
r'^(\+34|0034|34)?9\d{8}$', # Landline
|
|
]
|
|
if not any(re.match(pattern, phone) for pattern in patterns):
|
|
raise ValueError('Invalid Spanish phone number')
|
|
return v
|
|
|
|
@field_validator('business_type')
|
|
@classmethod
|
|
def validate_business_type(cls, v):
|
|
"""Validate business type if provided"""
|
|
if v is None:
|
|
return v
|
|
valid_types = ['bakery', 'coffee_shop', 'pastry_shop', 'restaurant']
|
|
if v not in valid_types:
|
|
raise ValueError(f'Business type must be one of: {valid_types}')
|
|
return v
|
|
|
|
@field_validator('business_model')
|
|
@classmethod
|
|
def validate_business_model(cls, v):
|
|
"""Validate business model if provided"""
|
|
if v is None:
|
|
return v
|
|
valid_models = ['individual_bakery', 'central_baker_satellite', 'retail_bakery', 'hybrid_bakery']
|
|
if v not in valid_models:
|
|
raise ValueError(f'Business model must be one of: {valid_models}')
|
|
return v
|
|
|
|
@field_validator('timezone')
|
|
@classmethod
|
|
def validate_timezone(cls, v):
|
|
"""Validate timezone if provided"""
|
|
if v is None:
|
|
return v
|
|
# Basic timezone validation - should match common timezone formats
|
|
if not re.match(r'^[A-Za-z_+/]+$', v):
|
|
raise ValueError('Invalid timezone format')
|
|
return v
|
|
|
|
|
|
class BulkChildTenantsCreate(BaseModel):
|
|
"""Schema for bulk creating child tenants during onboarding"""
|
|
child_tenants: List[ChildTenantCreate] = Field(
|
|
...,
|
|
min_length=1,
|
|
max_length=50,
|
|
description="List of child tenants to create (1-50)"
|
|
)
|
|
|
|
# Optional: Auto-configure distribution routes
|
|
auto_configure_distribution: bool = Field(
|
|
True,
|
|
description="Whether to automatically set up distribution routes between parent and children"
|
|
)
|
|
|
|
@field_validator('child_tenants')
|
|
@classmethod
|
|
def validate_unique_location_codes(cls, v):
|
|
"""Ensure all location codes are unique within the batch"""
|
|
location_codes = [ct.location_code for ct in v]
|
|
if len(location_codes) != len(set(location_codes)):
|
|
raise ValueError('Location codes must be unique within the batch')
|
|
return v
|
|
|
|
|
|
class ChildTenantResponse(TenantResponse):
|
|
"""Response schema for child tenant - extends TenantResponse"""
|
|
location_code: Optional[str] = None
|
|
zone: Optional[str] = None
|
|
hierarchy_path: Optional[str] = None
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
|
|
class BulkChildTenantsResponse(BaseModel):
|
|
"""Response schema for bulk child tenant creation"""
|
|
parent_tenant_id: str
|
|
created_count: int
|
|
failed_count: int
|
|
created_tenants: List[ChildTenantResponse]
|
|
failed_tenants: List[Dict[str, Any]] = Field(
|
|
default_factory=list,
|
|
description="List of failed tenants with error details"
|
|
)
|
|
distribution_configured: bool = False
|
|
|
|
@field_validator('parent_tenant_id', mode='before')
|
|
@classmethod
|
|
def convert_uuid_to_string(cls, v):
|
|
"""Convert UUID objects to strings for JSON serialization"""
|
|
if isinstance(v, UUID):
|
|
return str(v)
|
|
return v
|
|
|
|
class TenantHierarchyResponse(BaseModel):
|
|
"""Response schema for tenant hierarchy information"""
|
|
tenant_id: str
|
|
tenant_type: str = Field(..., description="Type: standalone, parent, or child")
|
|
parent_tenant_id: Optional[str] = Field(None, description="Parent tenant ID if this is a child")
|
|
hierarchy_path: Optional[str] = Field(None, description="Materialized path for hierarchy queries")
|
|
child_count: int = Field(0, description="Number of child tenants (for parent tenants)")
|
|
hierarchy_level: int = Field(0, description="Level in hierarchy: 0=parent, 1=child, 2=grandchild, etc.")
|
|
|
|
@field_validator('tenant_id', 'parent_tenant_id', mode='before')
|
|
@classmethod
|
|
def convert_uuid_to_string(cls, v):
|
|
"""Convert UUID objects to strings for JSON serialization"""
|
|
if v is None:
|
|
return v
|
|
if isinstance(v, UUID):
|
|
return str(v)
|
|
return v
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
|
|
class TenantSearchRequest(BaseModel):
|
|
"""Tenant search request schema"""
|
|
query: Optional[str] = None
|
|
business_type: Optional[str] = None
|
|
city: Optional[str] = None
|
|
status: Optional[str] = None
|
|
limit: int = Field(default=50, ge=1, le=100)
|
|
offset: int = Field(default=0, ge=0)
|