JoeYing
Add ReScopeBench cases and task preview
f726fd6
Raw History Blame Contribute Delete
87.6 kB
"""Tool implementations for the cinema chain environment."""
from __future__ import annotations
import re
from datetime import timedelta
from typing import Any, Dict, List
from mcp_servers.server import register_tool
from mcp_servers.utils import error_response, success_response, slugify, validate_email_address, validate_phone
from mcp_servers.cinema_lib import *
def list_venues(state_manager, status=None, state=None, city_keyword=None, amenity=None, sort_by="name", sort_order="asc", offset=0, limit=25):
for name, value, enum in [("status", status, "venue_status")]:
err = validate_enum(name, value, enum, optional=True)
if err: return err
if sort_by not in {"name", "city", "state", "updated_at"} or sort_order not in {"asc", "desc"}:
return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
for name, value in [("state", state), ("city_keyword", city_keyword), ("amenity", amenity)]:
if value is not None and not isinstance(value, str):
return error_response("INVALID_PARAMETER", f"{name} must be a string")
err = validate_pagination(offset, limit)
if err: return err
data = rows(state_manager, "venue")
if status: data = [v for v in data if v.get("status") == status]
if state: data = [v for v in data if v.get("state", "").lower() == state.lower()]
if city_keyword: data = [v for v in data if city_keyword.lower() in v.get("city", "").lower()]
if amenity: data = [v for v in data if any(amenity.lower() == a.lower() for a in v.get("amenities", []))]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "venue_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "venues": [{k:v.get(k) for k in ["venue_id","name","city","state","timezone","status","amenities"]} for v in page]})
def get_auditorium_seat_map(state_manager, auditorium_id=None, include_unavailable=True, seat_status=None, price_zone=None):
err = require_one("auditorium_id", auditorium_id, "MISSING_AUDITORIUM_ID")
if err: return err
err = validate_bool("include_unavailable", include_unavailable, optional=False)
if err: return err
err = validate_enum("seat_status", seat_status, "seat_status", optional=True) or validate_enum("price_zone", price_zone, "price_zone", optional=True)
if err: return err
auditorium = get(state_manager, "auditorium", auditorium_id)
if not auditorium: return error_response("AUDITORIUM_NOT_FOUND", "Auditorium does not exist")
venue = get(state_manager, "venue", auditorium["venue_id"])
seat_rows = [s for s in rows(state_manager, "seat") if s.get("auditorium_id") == auditorium_id]
if not include_unavailable: seat_rows = [s for s in seat_rows if s.get("status") == "available"]
if seat_status: seat_rows = [s for s in seat_rows if s.get("status") == seat_status]
if price_zone: seat_rows = [s for s in seat_rows if s.get("price_zone") == price_zone]
grouped = {}
for seat in sorted(seat_rows, key=lambda s: (s.get("row_label"), s.get("seat_number"))):
grouped.setdefault(seat["row_label"], []).append({k: seat.get(k) for k in ["seat_id","row_label","seat_number","seat_type","status","price_zone"]})
return success_response({"auditorium": {k: auditorium.get(k) for k in ["auditorium_id","venue_id","name","screen_format","capacity","status"]}, "venue": {"venue_id": venue.get("venue_id"), "name": venue.get("name")} if venue else None, "seat_totals": {"returned": len(seat_rows), "available": sum(1 for s in seat_rows if s.get("status")=="available"), "maintenance": sum(1 for s in seat_rows if s.get("status")=="maintenance"), "blocked": sum(1 for s in seat_rows if s.get("status")=="blocked")}, "rows": [{"row_label": row, "seats": seats} for row, seats in grouped.items()]})
def list_movies(state_manager, status=None, rating=None, genre=None, keyword=None, sort_by="title", sort_order="asc", offset=0, limit=25):
err = validate_enum("status", status, "movie_status", optional=True) or validate_enum("rating", rating, "rating", optional=True)
if err: return err
if sort_by not in {"title", "release_date", "runtime_minutes", "updated_at"} or sort_order not in {"asc", "desc"}:
return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
for name, value in [("genre", genre), ("keyword", keyword)]:
if value is not None and not isinstance(value, str): return error_response("INVALID_PARAMETER", f"{name} must be a string")
err = validate_pagination(offset, limit)
if err: return err
data = rows(state_manager, "movie")
if status: data = [m for m in data if m.get("status") == status]
if rating: data = [m for m in data if m.get("rating") == rating]
if genre: data = [m for m in data if any(genre.lower() == g.lower() for g in m.get("genres", []))]
if keyword: data = [m for m in data if keyword.lower() in (m.get("title", "") + " " + m.get("distributor", "")).lower()]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "movie_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "movies": [{k:m.get(k) for k in ["movie_id","title","rating","runtime_minutes","genres","release_date","status"]} for m in page]})
def search_showtimes(state_manager, venue_id=None, movie_id=None, start_date=None, end_date=None, format=None, status=None, min_seats_available=0, sort_by="starts_at", sort_order="asc", offset=0, limit=25):
if not any([venue_id, movie_id, start_date, end_date, format, status, min_seats_available]):
return error_response("NO_FILTERS", "At least one search filter is required")
err = validate_enum("format", format, "showtime_format", optional=True) or validate_enum("status", status, "showtime_status", optional=True)
if err: return err
if sort_by not in {"starts_at", "seats_available", "revenue_gross"} or sort_order not in {"asc", "desc"}:
return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
if not isinstance(min_seats_available, int) or isinstance(min_seats_available, bool) or min_seats_available < 0:
return error_response("OUT_OF_RANGE", "min_seats_available must be non-negative")
err = validate_pagination(offset, limit)
if err: return err
start_dt = parse_datetime(start_date) if start_date else None
end_dt = parse_datetime(end_date) if end_date else None
if (start_date and not start_dt) or (end_date and not end_dt): return error_response("INVALID_PARAMETER", "date filters must be ISO datetimes")
if start_dt and end_dt and start_dt > end_dt: return error_response("INVALID_DATE_RANGE", "start_date must be before end_date")
if venue_id and not get(state_manager, "venue", venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if movie_id and not get(state_manager, "movie", movie_id): return error_response("MOVIE_NOT_FOUND", "Movie does not exist")
data = rows(state_manager, "showtime")
if venue_id: data = [s for s in data if s.get("venue_id") == venue_id]
if movie_id: data = [s for s in data if s.get("movie_id") == movie_id]
if start_dt: data = [s for s in data if parse_datetime(s.get("starts_at")) and parse_datetime(s.get("starts_at")) >= start_dt]
if end_dt: data = [s for s in data if parse_datetime(s.get("starts_at")) and parse_datetime(s.get("starts_at")) <= end_dt]
if format: data = [s for s in data if s.get("format") == format]
if status: data = [s for s in data if s.get("status") == status]
data = [s for s in data if int(s.get("seats_available", 0) or 0) >= min_seats_available]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "showtime_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "showtimes": [{k:s.get(k) for k in ["showtime_id","venue_id","movie_id","auditorium_id","starts_at","status","format","seats_available","revenue_gross"]} for s in page]})
def get_showtime_availability(state_manager, showtime_id=None, include_seat_details=False, price_zone=None):
err = require_one("showtime_id", showtime_id, "MISSING_SHOWTIME_ID")
if err: return err
err = validate_bool("include_seat_details", include_seat_details, optional=False) or validate_enum("price_zone", price_zone, "price_zone", optional=True)
if err: return err
showtime = get(state_manager, "showtime", showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
summary = showtime_seat_summary(state_manager, showtime)
plan_rows = [get(state_manager, "pricing_plan", pid) for pid in showtime.get("pricing_plan_ids", [])]
data = {"showtime_id": showtime_id, "status": showtime.get("status"), "capacity": summary["capacity"], "availability": summary, "pricing_plans": [{k:p.get(k) for k in ["pricing_plan_id","name","ticket_type","base_price","service_fee","currency","status"]} for p in plan_rows if p]}
if include_seat_details:
held = active_hold_seats(state_manager, showtime_id); ticketed = issued_ticket_seats(state_manager, showtime_id)
seat_rows=[]
for seat in rows(state_manager, "seat"):
if seat.get("auditorium_id") != showtime.get("auditorium_id"): continue
if price_zone and seat.get("price_zone") != price_zone: continue
derived = "ticketed" if seat["seat_id"] in ticketed else "held" if seat["seat_id"] in held else seat.get("status")
seat_rows.append({"seat_id": seat["seat_id"], "row_label": seat.get("row_label"), "seat_number": seat.get("seat_number"), "price_zone": seat.get("price_zone"), "availability_state": derived})
data["seats"] = seat_rows
return success_response(data)
def list_pricing_plans(state_manager, venue_id=None, ticket_type=None, channel=None, status=None, sort_by="base_price", sort_order="asc", offset=0, limit=25):
err = require_one("venue_id", venue_id, "MISSING_VENUE_ID")
if err: return err
for name, value, enum in [("ticket_type", ticket_type, "ticket_type"), ("channel", channel, "pricing_channel"), ("status", status, "pricing_status")]:
err = validate_enum(name, value, enum, optional=True)
if err: return err
if sort_by not in {"base_price", "name", "updated_at"} or sort_order not in {"asc", "desc"}: return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
err = validate_pagination(offset, limit)
if err: return err
if not get(state_manager, "venue", venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
data = [p for p in rows(state_manager, "pricing_plan") if p.get("venue_id") == venue_id]
if ticket_type: data = [p for p in data if p.get("ticket_type") == ticket_type]
if channel: data = [p for p in data if p.get("channel") == channel]
if status: data = [p for p in data if p.get("status") == status]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "pricing_plan_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "pricing_plans": [{k:p.get(k) for k in ["pricing_plan_id","name","ticket_type","base_price","service_fee","channel","status","rules"]} for p in page]})
def get_member_profile(state_manager, member_id=None, include_activity=False, activity_limit=5):
err = require_one("member_id", member_id, "MISSING_MEMBER_ID")
if err: return err
err = validate_bool("include_activity", include_activity, optional=False)
if err: return err
if not isinstance(activity_limit, int) or isinstance(activity_limit, bool) or activity_limit < 1 or activity_limit > 25: return error_response("OUT_OF_RANGE", "activity_limit must be from 1 to 25")
member = get(state_manager, "member", member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
venue = get(state_manager, "venue", member.get("home_venue_id"))
profile = {k: member.get(k) for k in ["member_id","full_name","email_address","tier","points_balance","lifetime_spend","status"]}
profile["home_venue"] = {"venue_id": venue.get("venue_id"), "name": venue.get("name"), "city": venue.get("city")} if venue else None
profile["benefits"] = member_benefits(member.get("tier"))
data = {"member": profile}
if include_activity: data["recent_activity"] = summarize_activity(state_manager, member_id, activity_limit)
return success_response(data)
def list_concession_items(state_manager, venue_id=None, category=None, status=None, max_unit_price=None, sort_by="name", sort_order="asc", offset=0, limit=25):
err = validate_enum("category", category, "concession_category", optional=True) or validate_enum("status", status, "pricing_status", optional=True)
if err: return err
if sort_by not in {"name", "unit_price", "category", "updated_at"} or sort_order not in {"asc", "desc"}: return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
if max_unit_price is not None and (not isinstance(max_unit_price, (int,float)) or isinstance(max_unit_price, bool) or max_unit_price < 0): return error_response("OUT_OF_RANGE", "max_unit_price must be non-negative")
err = validate_pagination(offset, limit)
if err: return err
if venue_id and not get(state_manager, "venue", venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
data = rows(state_manager, "concession_item")
if venue_id: data = [i for i in data if venue_id in i.get("venue_ids", [])]
if category: data = [i for i in data if i.get("category") == category]
if status: data = [i for i in data if i.get("status") == status]
if max_unit_price is not None: data = [i for i in data if float(i.get("unit_price", 0)) <= float(max_unit_price)]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "item_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "items": [{k:i.get(k) for k in ["item_id","name","category","unit_price","tax_rate","status","venue_ids","loyalty_points"]} for i in page]})
def get_box_office_report(state_manager, venue_id=None, start_date=None, end_date=None, status=None, include_zero_days=True):
err = require_fields(locals(), ["venue_id", "start_date", "end_date"])
if err: return err
start = parse_date(start_date); end = parse_date(end_date)
if not start or not end: return error_response("INVALID_DATE", "Dates must use YYYY-MM-DD")
if start > end or (end - start).days > 45: return error_response("INVALID_DATE_RANGE", "Date range is invalid or too wide")
err = validate_enum("status", status, "box_day_status", optional=True) or validate_bool("include_zero_days", include_zero_days, optional=False)
if err: return err
if not get(state_manager, "venue", venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
data = [d for d in rows(state_manager, "box_office_day") if d.get("venue_id") == venue_id and start_date <= d.get("business_date", "") <= end_date]
if status: data = [d for d in data if d.get("status") == status]
if not include_zero_days: data = [d for d in data if any(float(d.get(field,0) or 0)>0 for field in ["gross_ticket_sales","gross_concession_sales","refunds_total","taxes_total"])]
data = sorted(data, key=lambda d: d.get("business_date"))
summary = {"gross_ticket_sales": round(sum(float(d.get("gross_ticket_sales",0) or 0) for d in data),2), "gross_concession_sales": round(sum(float(d.get("gross_concession_sales",0) or 0) for d in data),2), "refunds_total": round(sum(float(d.get("refunds_total",0) or 0) for d in data),2), "taxes_total": round(sum(float(d.get("taxes_total",0) or 0) for d in data),2), "tickets_sold": sum(int(d.get("tickets_sold",0) or 0) for d in data), "orders_count": sum(int(d.get("orders_count",0) or 0) for d in data), "payments_count": sum(int(d.get("payments_count",0) or 0) for d in data)}
return success_response({"venue_id": venue_id, "date_range": {"start_date": start_date, "end_date": end_date}, "summary": summary, "days": [{k:d.get(k) for k in ["box_office_day_id","business_date","status","gross_ticket_sales","gross_concession_sales","refunds_total","taxes_total","tickets_sold","orders_count","payments_count"]} for d in data]})
def list_group_reservations(state_manager, venue_id=None, showtime_id=None, status=None, customer_keyword=None, sort_by="created_at", sort_order="desc", offset=0, limit=25):
err = validate_enum("status", status, "group_status", optional=True)
if err: return err
if sort_by not in {"created_at", "requested_seats", "quote_amount", "updated_at"} or sort_order not in {"asc", "desc"}: return error_response("INVALID_PARAMETER", "sort_by or sort_order is invalid")
if customer_keyword is not None and not isinstance(customer_keyword, str): return error_response("INVALID_PARAMETER", "customer_keyword must be a string")
err = validate_pagination(offset, limit)
if err: return err
if venue_id and not get(state_manager, "venue", venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if showtime_id:
showtime = get(state_manager, "showtime", showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if venue_id and showtime.get("venue_id") != venue_id: return error_response("VENUE_SHOWTIME_MISMATCH", "Showtime belongs to another venue")
data = rows(state_manager, "group_reservation")
if venue_id: data = [g for g in data if g.get("venue_id") == venue_id]
if showtime_id: data = [g for g in data if g.get("showtime_id") == showtime_id]
if status: data = [g for g in data if g.get("status") == status]
if customer_keyword: data = [g for g in data if customer_keyword.lower() in (g.get("customer_name", "") + " " + g.get("notes", "")).lower()]
total, page = sort_page(data, sort_by, sort_order, offset, limit, "group_reservation_id")
return success_response({"total_count": total, "offset": offset, "limit": limit, "group_reservations": [{k:g.get(k) for k in ["group_reservation_id","venue_id","showtime_id","customer_name","requested_seats","status","quote_amount","deposit_paid"]} for g in page]})
def schedule_showtime(state_manager, venue_id=None, auditorium_id=None, movie_id=None, starts_at=None, format=None, pricing_plan_ids=None, status="scheduled", language="English"):
err = require_fields(locals(), ["venue_id","auditorium_id","movie_id","starts_at","format","pricing_plan_ids"])
if err: return err
err = validate_enum("format", format, "showtime_format", optional=False) or validate_enum("status", status, "showtime_status", optional=False)
if err: return err
if status not in {"scheduled", "sales_open"}: return error_response("INVALID_PARAMETER", "initial status must be scheduled or sales_open")
start = parse_datetime(starts_at)
if not start or start <= RUNTIME_NOW: return error_response("INVALID_PARAMETER", "starts_at must be a valid future datetime")
venue = get(state_manager,"venue",venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if venue.get("status") != "open": return error_response("VENUE_NOT_OPEN", "Venue is not open")
aud = get(state_manager,"auditorium",auditorium_id)
if not aud: return error_response("AUDITORIUM_NOT_FOUND", "Auditorium does not exist")
if aud.get("venue_id") != venue_id: return error_response("AUDITORIUM_VENUE_MISMATCH", "Auditorium belongs to another venue")
if aud.get("status") != "active": return error_response("AUDITORIUM_UNAVAILABLE", "Auditorium is not active")
movie = get(state_manager,"movie",movie_id)
if not movie: return error_response("MOVIE_NOT_FOUND", "Movie does not exist")
if movie.get("status") == "ended": return error_response("MOVIE_NOT_SCHEDULABLE", "Movie is ended")
if not isinstance(pricing_plan_ids, list) or not pricing_plan_ids: return error_response("INVALID_PARAMETER", "pricing_plan_ids must be a non-empty list")
for pid in pricing_plan_ids:
plan = get(state_manager,"pricing_plan",pid)
if not plan: return error_response("PRICING_PLAN_NOT_FOUND", "Pricing plan does not exist")
if plan.get("status") != "active": return error_response("PRICING_PLAN_INACTIVE", "Pricing plan is inactive")
if plan.get("venue_id") != venue_id: return error_response("PRICING_PLAN_VENUE_MISMATCH", "Pricing plan belongs to another venue")
end = start + timedelta(minutes=int(movie.get("runtime_minutes", 0) or 0) + 28)
for other in rows(state_manager,"showtime"):
if other.get("auditorium_id") == auditorium_id and other.get("status") != "cancelled":
os = parse_datetime(other.get("starts_at")); oe = parse_datetime(other.get("ends_at"))
if os and oe and not (end + timedelta(minutes=20) <= os or start >= oe + timedelta(minutes=20)):
return error_response("SHOWTIME_OVERLAP", "Requested showtime overlaps another showtime")
sid = f"showtime-{venue_id.removeprefix('venue-')}-{auditorium_id.split(venue_id.removeprefix('venue-')+'-',1)[-1]}-{isoformat_z(start)[:16].lower().replace(':','-')}-{slugify(movie.get('title'))}"
existing = {s.get("showtime_id") for s in rows(state_manager,"showtime")}; base=sid; idx=1
while sid in existing: idx+=1; sid=f"{base}-{idx}"
record={"showtime_id":sid,"venue_id":venue_id,"auditorium_id":auditorium_id,"movie_id":movie_id,"starts_at":isoformat_z(start),"ends_at":isoformat_z(end),"business_date":isoformat_z(start)[:10],"language":language or "English","format":format,"status":status,"pricing_plan_ids":pricing_plan_ids,"capacity":int(aud.get("capacity",0)),"seats_sold":0,"seats_held":0,"seats_available":int(aud.get("capacity",0)),"revenue_gross":0.0,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"showtime",record)
return success_response({k:record.get(k) for k in ["showtime_id","venue_id","auditorium_id","movie_id","starts_at","ends_at","status","capacity","pricing_plan_ids"]})
def update_showtime_status(state_manager, showtime_id=None, new_status=None, reason=None):
err = require_fields(locals(), ["showtime_id","new_status"])
if err: return err
err = validate_enum("new_status", new_status, "showtime_status", optional=False)
if err: return err
showtime = get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
prev = showtime.get("status")
if prev == new_status: return error_response("STATUS_UNCHANGED", "Requested status equals current status")
if prev == "completed" and new_status in {"scheduled","sales_open"}: return error_response("INVALID_STATUS_TRANSITION", "Completed showtime cannot reopen")
if new_status == "sold_out" and int(showtime.get("seats_available",0) or 0) != 0: return error_response("SOLD_OUT_PRECONDITION_FAILED", "Sold-out status requires zero available seats")
tickets=[t for t in rows(state_manager,"ticket") if t.get("showtime_id")==showtime_id and t.get("status") in {"issued","checked_in"}]
if new_status == "cancelled" and tickets and is_blank(reason): return error_response("CANCEL_REASON_REQUIRED", "Cancellation with tickets requires a reason")
released=0; voided=0
if new_status == "cancelled":
for hold in rows(state_manager,"seat_hold"):
if hold.get("showtime_id")==showtime_id and hold.get("status")=="active":
update(state_manager,"seat_hold",hold["hold_id"],{"status":"released","updated_at":RUNTIME_NOW_ISO}); released+=1
for ticket in tickets:
update(state_manager,"ticket",ticket["ticket_id"],{"status":"voided","updated_at":RUNTIME_NOW_ISO}); voided+=1
update(state_manager,"showtime",showtime_id,{"status":new_status,"updated_at":RUNTIME_NOW_ISO})
updated = recompute_showtime(state_manager, showtime_id) or get(state_manager,"showtime",showtime_id)
return success_response({"showtime_id":showtime_id,"previous_status":prev,"new_status":new_status,"released_hold_count":released,"voided_ticket_count":voided,"availability":{"seats_held":updated.get("seats_held"),"seats_available":updated.get("seats_available")}})
def set_seat_maintenance_status(state_manager, seat_id=None, new_status=None, reason=None):
err = require_fields(locals(), ["seat_id","new_status"])
if err: return err
err = validate_enum("new_status", new_status, "seat_status", optional=False)
if err: return err
seat = get(state_manager,"seat",seat_id)
if not seat: return error_response("SEAT_NOT_FOUND", "Seat does not exist")
prev=seat.get("status")
if prev == new_status: return error_response("STATUS_UNCHANGED", "Requested status equals current status")
if new_status in {"blocked","maintenance"} and is_blank(reason): return error_response("REASON_REQUIRED", "Reason is required")
for hold in rows(state_manager,"seat_hold"):
st=get(state_manager,"showtime",hold.get("showtime_id"))
if hold.get("status")=="active" and seat_id in (hold.get("seat_ids") or []) and st and parse_datetime(st.get("starts_at")) and parse_datetime(st.get("starts_at")) > RUNTIME_NOW:
return error_response("ACTIVE_HOLD_CONFLICT", "Seat is in an active future hold")
for ticket in rows(state_manager,"ticket"):
st=get(state_manager,"showtime",ticket.get("showtime_id"))
if ticket.get("seat_id")==seat_id and ticket.get("status") in {"issued","checked_in"} and st and st.get("status") != "cancelled" and parse_datetime(st.get("starts_at")) and parse_datetime(st.get("starts_at")) > RUNTIME_NOW:
return error_response("ISSUED_TICKET_CONFLICT", "Seat has an issued ticket for a future showtime")
update(state_manager,"seat",seat_id,{"status":new_status,"updated_at":RUNTIME_NOW_ISO})
affected=[]
for st in rows(state_manager,"showtime"):
if st.get("auditorium_id")==seat.get("auditorium_id") and parse_datetime(st.get("starts_at")) and parse_datetime(st.get("starts_at"))>RUNTIME_NOW and st.get("status") in {"scheduled","sales_open","sold_out"}:
recompute_showtime(state_manager, st["showtime_id"]); affected.append(st["showtime_id"])
return success_response({"seat_id":seat_id,"previous_status":prev,"new_status":new_status,"affected_showtime_ids":affected,"updated_availability_delta":len(affected)})
def _validate_selected_pricing_context(
state_manager,
showtime,
seat_ids,
pricing_plan_id=None,
ticket_type=None,
channel=None,
):
if not pricing_plan_id and not ticket_type:
first_seat = get(state_manager, "seat", (seat_ids or [None])[0])
plan = ticket_pricing_plan(state_manager, showtime, first_seat or {})
return plan, None
if not pricing_plan_id or not ticket_type:
return None, error_response(
"PRICING_CONTEXT_REQUIRED",
"pricing_plan_id and ticket_type must be supplied together",
)
plan = get(state_manager, "pricing_plan", pricing_plan_id)
if not plan:
return None, error_response("PRICING_PLAN_NOT_FOUND", "Pricing plan does not exist")
if (
plan.get("status") != "active"
or plan.get("venue_id") != showtime.get("venue_id")
or pricing_plan_id not in (showtime.get("pricing_plan_ids") or [])
):
return None, error_response(
"PRICING_PLAN_NOT_ELIGIBLE",
"Pricing plan is not active for this showtime",
)
if plan.get("ticket_type") != ticket_type:
return None, error_response(
"TICKET_TYPE_MISMATCH",
"Ticket type does not match the selected pricing plan",
)
rules = plan.get("rules") or {}
required_channel = rules.get("checkout_channel")
if required_channel and required_channel != channel:
return None, error_response(
"CHECKOUT_CHANNEL_MISMATCH",
"Checkout channel is not eligible for the selected pricing plan",
)
required_zone = rules.get("seat_zone")
if required_zone:
selected_seats = [get(state_manager, "seat", seat_id) for seat_id in (seat_ids or [])]
if any(seat and seat.get("price_zone") != required_zone for seat in selected_seats):
return None, error_response(
"PRICING_ZONE_MISMATCH",
"Selected seat is outside the pricing plan's eligible zone",
)
return plan, None
def create_seat_hold(state_manager, showtime_id=None, seat_ids=None, member_id=None, channel=None, hold_minutes=12, pricing_plan_id=None, ticket_type=None):
err = require_fields(locals(), ["showtime_id","seat_ids","channel"])
if err: return err
err = validate_enum("channel", channel, "hold_channel", optional=False)
if err: return err
err = validate_int_range("hold_minutes", hold_minutes, 1, 30)
if err: return err
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("status") not in {"sales_open","scheduled"}: return error_response("SHOWTIME_NOT_HOLDABLE", "Showtime does not allow holds")
if member_id:
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member is not active")
err=validate_seat_selection(state_manager, showtime, seat_ids, max_count=12)
if err: return err
plan, err = _validate_selected_pricing_context(
state_manager,
showtime,
seat_ids,
pricing_plan_id=pricing_plan_id,
ticket_type=ticket_type,
channel=channel,
)
if err: return err
hold_id=build_hold_id(state_manager, showtime["venue_id"])
expires=RUNTIME_NOW + timedelta(minutes=hold_minutes)
rules = (plan or {}).get("rules") or {}
hold={"hold_id":hold_id,"showtime_id":showtime_id,"member_id":member_id,"channel":channel,"seat_ids":seat_ids,"status":"active","expires_at":isoformat_z(expires),"converted_booking_id":None,"pricing_plan_id":(plan or {}).get("pricing_plan_id"),"ticket_type":(plan or {}).get("ticket_type"),"price_zone":rules.get("seat_zone"),"policy_version":rules.get("policy_version"),"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"seat_hold",hold); updated=recompute_showtime(state_manager, showtime_id)
return success_response({"hold_id":hold_id,"showtime_id":showtime_id,"seat_ids":seat_ids,"expires_at":hold["expires_at"],"seats_held":updated.get("seats_held"),"seats_available":updated.get("seats_available")})
def release_seat_hold(state_manager, hold_id=None, release_reason=None):
err = require_one("hold_id", hold_id, "MISSING_HOLD_ID")
if err: return err
hold=get(state_manager,"seat_hold",hold_id)
if not hold: return error_response("HOLD_NOT_FOUND", "Hold does not exist")
if hold.get("status") != "active": return error_response("HOLD_NOT_ACTIVE", "Hold is not active")
showtime=get(state_manager,"showtime",hold.get("showtime_id"))
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Linked showtime is missing")
if showtime.get("status") in {"completed","cancelled"}: return error_response("SHOWTIME_CLOSED", "Linked showtime is closed")
update(state_manager,"seat_hold",hold_id,{"status":"released","updated_at":RUNTIME_NOW_ISO}); updated=recompute_showtime(state_manager, hold["showtime_id"])
return success_response({"hold_id":hold_id,"released_seat_count":len(hold.get("seat_ids") or []),"showtime_id":hold.get("showtime_id"),"seats_held":updated.get("seats_held"),"seats_available":updated.get("seats_available")})
def create_booking(state_manager, showtime_id=None, seat_ids=None, customer_name=None, customer_email=None, member_id=None, hold_id=None, promo_code_id=None, channel=None, payment_method=None, capture_payment=True, pricing_plan_id=None, ticket_type=None):
err=require_fields(locals(), ["showtime_id","seat_ids","customer_name","customer_email","channel"])
if err: return err
if not validate_email_address(customer_email): return error_response("INVALID_PARAMETER", "customer_email is invalid")
err=validate_enum("channel", channel, "booking_channel", optional=False) or validate_enum("payment_method", payment_method, "payment_method", optional=True) or validate_bool("capture_payment", capture_payment, optional=False)
if err: return err
if capture_payment and not payment_method: return error_response("PAYMENT_METHOD_REQUIRED", "payment_method is required when capture_payment is true")
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("status") != "sales_open": return error_response("SHOWTIME_NOT_BOOKABLE", "Showtime is not sales open")
member=None
if member_id:
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member is not active")
hold=None; except_hold=None
if hold_id:
hold=get(state_manager,"seat_hold",hold_id)
if not hold: return error_response("HOLD_NOT_FOUND", "Hold does not exist")
if hold.get("status") != "active": return error_response("HOLD_NOT_ACTIVE", "Hold is not active")
if hold.get("showtime_id") != showtime_id: return error_response("HOLD_SHOWTIME_MISMATCH", "Hold belongs to another showtime")
if set(hold.get("seat_ids") or []) != set(seat_ids or []): return error_response("HOLD_SEAT_MISMATCH", "Requested seats do not match hold")
except_hold=hold_id
err=validate_seat_selection(state_manager, showtime, seat_ids, max_count=12, except_hold_id=except_hold)
if err: return err
plan, err = _validate_selected_pricing_context(
state_manager,
showtime,
seat_ids,
pricing_plan_id=pricing_plan_id,
ticket_type=ticket_type,
channel=channel,
)
if err: return err
if hold and pricing_plan_id and (
hold.get("pricing_plan_id") != pricing_plan_id
or hold.get("ticket_type") != ticket_type
or hold.get("channel") != channel
):
return error_response(
"HOLD_PRICING_CONTEXT_MISMATCH",
"Seat hold does not match the requested pricing context",
)
promo, err = validate_promo_for_booking(state_manager, promo_code_id, showtime)
if err: return err
try: ticket_rows, subtotal, discount, service, total = calculate_ticket_total(state_manager, showtime, seat_ids, member, promo, pricing_plan_id=(plan or {}).get("pricing_plan_id"))
except ValueError: return error_response("PRICING_PLAN_UNAVAILABLE", "No active pricing plan can price the requested ticket")
booking_id=build_booking_id(state_manager, showtime["venue_id"], customer_name, showtime["business_date"])
rules = (plan or {}).get("rules") or {}
booking={"booking_id":booking_id,"showtime_id":showtime_id,"member_id":member_id,"hold_id":hold_id,"promo_code_id":promo_code_id,"channel":channel,"customer_name":customer_name,"customer_email":customer_email,"status":"paid" if capture_payment else "pending_payment","ticket_count":len(seat_ids),"subtotal":subtotal,"discount_total":discount,"service_fee_total":service,"total_amount":total,"payment_status":"captured" if capture_payment else "unpaid","pricing_plan_id":(plan or {}).get("pricing_plan_id"),"ticket_type":(plan or {}).get("ticket_type"),"price_zone":rules.get("seat_zone"),"policy_version":rules.get("policy_version"),"source_group_reservation_id":None,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO,"cancelled_at":None}
add(state_manager,"booking",booking)
ticket_ids=[]
for tr in ticket_rows:
tid=build_ticket_id(booking_id,tr["seat_id"]); ticket_ids.append(tid)
add(state_manager,"ticket",{"ticket_id":tid,"booking_id":booking_id,"showtime_id":showtime_id,"seat_id":tr["seat_id"],"pricing_plan_id":tr["pricing_plan_id"],"ticket_type":tr["ticket_type"],"status":"issued","face_value":tr["face_value"],"discount_amount":tr["discount_amount"],"barcode":f"scan-{slugify(booking_id)}-{slugify(tr['seat_id'])}","checked_in_at":None,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO})
payment_id=None
if capture_payment:
payment=create_payment(state_manager, booking_id=booking_id, venue_id=showtime["venue_id"], amount=total, method=payment_method, status="captured")
payment_id=payment["payment_id"]
if member:
earned=int(round(total*10)); update(state_manager,"member",member_id,{"points_balance":int(member.get("points_balance",0))+earned,"lifetime_spend":round(float(member.get("lifetime_spend",0))+total,2),"updated_at":RUNTIME_NOW_ISO})
if hold: update(state_manager,"seat_hold",hold_id,{"status":"converted","converted_booking_id":booking_id,"updated_at":RUNTIME_NOW_ISO})
if promo: update(state_manager,"promo_code",promo["promo_code_id"],{"redeemed_count":int(promo.get("redeemed_count",0))+1,"updated_at":RUNTIME_NOW_ISO})
updated=recompute_showtime(state_manager, showtime_id); update(state_manager,"showtime",showtime_id,{"revenue_gross":round(float(updated.get("revenue_gross",showtime.get("revenue_gross",0)))+ (total if capture_payment else 0),2),"updated_at":RUNTIME_NOW_ISO})
updated=get(state_manager,"showtime",showtime_id)
return success_response({"booking_id":booking_id,"ticket_ids":ticket_ids,"payment_id":payment_id,"total_amount":total,"discount_total":discount,"payment_status":booking["payment_status"],"updated_showtime_availability":{"seats_sold":updated.get("seats_sold"),"seats_held":updated.get("seats_held"),"seats_available":updated.get("seats_available")}})
def cancel_booking(state_manager, booking_id=None, refund_mode=None, refund_amount=None, reason=None):
err=require_fields(locals(), ["booking_id","refund_mode","reason"])
if err: return err
err=validate_enum("refund_mode", refund_mode, "refund_mode", optional=False)
if err: return err
booking=get(state_manager,"booking",booking_id)
if not booking: return error_response("BOOKING_NOT_FOUND", "Booking does not exist")
if booking.get("status") in {"cancelled","refunded"}: return error_response("BOOKING_NOT_CANCELLABLE", "Booking is already cancelled or refunded")
showtime=get(state_manager,"showtime",booking.get("showtime_id"))
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Linked showtime is missing")
tickets=[t for t in rows(state_manager,"ticket") if t.get("booking_id")==booking_id and t.get("status") in {"issued","checked_in"}]
if any(t.get("checked_in_at") for t in tickets) and showtime.get("status") != "cancelled": return error_response("CHECKED_IN_TICKET_CONFLICT", "Checked-in tickets block cancellation")
payments=[p for p in rows(state_manager,"payment") if p.get("booking_id")==booking_id and p.get("status")=="captured"]
if refund_mode in {"full","partial"} and not payments: return error_response("PAYMENT_NOT_CAPTURED", "Refund requires captured payment")
amount=0.0
if refund_mode == "partial":
if not isinstance(refund_amount,(int,float)) or isinstance(refund_amount,bool) or refund_amount <= 0 or refund_amount > float(booking.get("total_amount",0)):
return error_response("OUT_OF_RANGE", "partial refund amount is invalid")
amount=round(float(refund_amount),2); new_status="partially_refunded"; payment_status="refunded"
elif refund_mode == "full":
amount=round(float(booking.get("total_amount",0)),2); new_status="refunded"; payment_status="refunded"
else:
new_status="cancelled"; payment_status=booking.get("payment_status")
voided=[]
for ticket in tickets:
update(state_manager,"ticket",ticket["ticket_id"],{"status":"refunded" if refund_mode in {"full","partial"} else "voided","updated_at":RUNTIME_NOW_ISO}); voided.append(ticket["ticket_id"])
refund_payment_id=None
if amount>0:
refund=create_payment(state_manager, booking_id=booking_id, venue_id=showtime["venue_id"], amount=amount, method="card", status="refunded", processor_reference=f"refund-{slugify(booking_id)}")
refund_payment_id=refund["payment_id"]
update(state_manager,"booking",booking_id,{"status":new_status,"payment_status":payment_status,"cancelled_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO})
if booking.get("promo_code_id") and refund_mode in {"full","none"}:
promo=get(state_manager,"promo_code",booking["promo_code_id"])
if promo: update(state_manager,"promo_code",promo["promo_code_id"],{"redeemed_count":max(0,int(promo.get("redeemed_count",0))-1),"updated_at":RUNTIME_NOW_ISO})
if booking.get("member_id") and amount>0:
member=get(state_manager,"member",booking["member_id"])
if member:
points=int(round(amount*10)); update(state_manager,"member",member["member_id"],{"points_balance":max(0,int(member.get("points_balance",0))-points),"lifetime_spend":max(0,round(float(member.get("lifetime_spend",0))-amount,2)),"updated_at":RUNTIME_NOW_ISO})
updated=recompute_showtime(state_manager, booking["showtime_id"]); update(state_manager,"showtime",showtime["showtime_id"],{"revenue_gross":max(0,round(float(showtime.get("revenue_gross",0))-amount,2)),"updated_at":RUNTIME_NOW_ISO})
updated=get(state_manager,"showtime",showtime["showtime_id"])
return success_response({"booking_id":booking_id,"new_booking_status":new_status,"voided_ticket_ids":voided,"refund_payment_id":refund_payment_id,"refund_amount":amount,"updated_showtime_availability":{"seats_sold":updated.get("seats_sold"),"seats_available":updated.get("seats_available")}})
def add_concession_order(state_manager, venue_id=None, items=None, booking_id=None, showtime_id=None, member_id=None, channel=None, payment_method=None, pickup_time=None):
err=require_fields(locals(), ["venue_id","items","channel","payment_method"])
if err: return err
err=validate_enum("channel", channel, "concession_channel", optional=False) or validate_enum("payment_method", payment_method, "payment_method", optional=False)
if err: return err
venue=get(state_manager,"venue",venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if venue.get("status") != "open": return error_response("VENUE_NOT_OPEN", "Venue is not open")
if booking_id:
booking=get(state_manager,"booking",booking_id)
if not booking: return error_response("BOOKING_NOT_FOUND", "Booking does not exist")
bvenue=venue_from_booking(state_manager, booking)
if bvenue != venue_id: return error_response("BOOKING_VENUE_MISMATCH", "Booking belongs to another venue")
if showtime_id:
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("venue_id") != venue_id: return error_response("SHOWTIME_VENUE_MISMATCH", "Showtime belongs to another venue")
member=None
if member_id:
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member is not active")
if pickup_time and not parse_datetime(pickup_time): return error_response("INVALID_PARAMETER", "pickup_time must be an ISO datetime")
normalized, subtotal, tax_total, total, earned, err = calculate_concession_order(state_manager, venue_id, items)
if err: return err
existing={o.get("order_id") for o in rows(state_manager,"concession_order")}; base=f"order-{venue_id.removeprefix('venue-')}-2026-05-27t12-00"; idx=1; oid=f"{base}-{idx}"
while oid in existing: idx+=1; oid=f"{base}-{idx}"
order={"order_id":oid,"booking_id":booking_id,"venue_id":venue_id,"showtime_id":showtime_id,"member_id":member_id,"status":"paid","channel":channel,"pickup_time":pickup_time,"items":normalized,"subtotal":subtotal,"tax_total":tax_total,"total_amount":total,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"concession_order",order); payment=create_payment(state_manager, order_id=oid, venue_id=venue_id, amount=total, method=payment_method, status="captured")
if member and payment_method != "member_points": update(state_manager,"member",member_id,{"points_balance":int(member.get("points_balance",0))+earned,"updated_at":RUNTIME_NOW_ISO})
return success_response({"order_id":oid,"payment_id":payment["payment_id"],"venue_id":venue_id,"status":"paid","item_count":sum(i["quantity"] for i in normalized),"subtotal":subtotal,"tax_total":tax_total,"total_amount":total,"earned_points":earned if member else 0})
def update_concession_order_status(state_manager, order_id=None, new_status=None, reason=None):
err=require_fields(locals(), ["order_id","new_status"])
if err: return err
err=validate_enum("new_status", new_status, "concession_status", optional=False)
if err: return err
if new_status == "paid": return error_response("INVALID_PARAMETER", "new_status must move away from paid")
order=get(state_manager,"concession_order",order_id)
if not order: return error_response("ORDER_NOT_FOUND", "Concession order does not exist")
prev=order.get("status")
if prev == new_status: return error_response("STATUS_UNCHANGED", "Requested status equals current status")
allowed={"paid":{"preparing","cancelled","refunded"},"preparing":{"ready","cancelled","refunded"},"ready":{"picked_up","refunded"}}
if new_status not in allowed.get(prev,set()): return error_response("INVALID_STATUS_TRANSITION", "Lifecycle transition is not allowed")
if new_status in {"cancelled","refunded"} and is_blank(reason): return error_response("REASON_REQUIRED", "Reason is required for cancellation or refund")
payments=[p for p in rows(state_manager,"payment") if p.get("order_id")==order_id and p.get("status")=="captured"]
if new_status == "refunded" and not payments: return error_response("PAYMENT_NOT_CAPTURED", "Refund requires captured payment")
refund_payment_id=None
if new_status == "refunded":
refund=create_payment(state_manager, order_id=order_id, venue_id=order["venue_id"], amount=order.get("total_amount",0), method="card", status="refunded", processor_reference=f"refund-{slugify(order_id)}")
refund_payment_id=refund["payment_id"]
if order.get("member_id"):
member=get(state_manager,"member",order["member_id"])
if member:
points=sum((get(state_manager,"concession_item",i["item_id"]) or {}).get("loyalty_points",0)*int(i.get("quantity",1)) for i in order.get("items",[]))
update(state_manager,"member",member["member_id"],{"points_balance":max(0,int(member.get("points_balance",0))-points),"updated_at":RUNTIME_NOW_ISO})
pickup_time=RUNTIME_NOW_ISO if new_status == "picked_up" else order.get("pickup_time")
update(state_manager,"concession_order",order_id,{"status":new_status,"pickup_time":pickup_time,"updated_at":RUNTIME_NOW_ISO})
return success_response({"order_id":order_id,"previous_status":prev,"new_status":new_status,"refund_payment_id":refund_payment_id,"pickup_time":pickup_time})
def register_member(state_manager, home_venue_id=None, full_name=None, email_address=None, phone=None, preferred_tier="classic"):
err=require_fields(locals(), ["home_venue_id","full_name","email_address","phone"])
if err: return err
err=validate_enum("preferred_tier", preferred_tier, "member_tier", optional=False)
if err: return err
if not validate_email_address(email_address) or not validate_phone(phone): return error_response("INVALID_PARAMETER", "email_address or phone is invalid")
venue=get(state_manager,"venue",home_venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Home venue does not exist")
if venue.get("status") == "closed": return error_response("VENUE_CLOSED", "Home venue is closed")
if any(m.get("email_address","").lower()==email_address.lower() for m in rows(state_manager,"member")): return error_response("DUPLICATE_MEMBER_EMAIL", "Member email is already used")
if preferred_tier != "classic": return error_response("TIER_PRECONDITION_FAILED", "New members must start in classic tier")
existing={m.get("member_id") for m in rows(state_manager,"member")}; base=f"member-{slugify(full_name)}-film-member-1"; mid=base; idx=1
while mid in existing: idx+=1; mid=f"member-{slugify(full_name)}-film-member-{idx}"
member={"member_id":mid,"home_venue_id":home_venue_id,"full_name":full_name,"email_address":email_address,"phone":phone,"tier":"classic","points_balance":0,"lifetime_spend":0.0,"status":"active","joined_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"member",member)
return success_response({k:member.get(k) for k in ["member_id","home_venue_id","full_name","email_address","tier","points_balance","status"]})
def update_member_tier(state_manager, member_id=None, new_tier=None, reason=None, allow_downgrade=False):
err=require_fields(locals(), ["member_id","new_tier","reason"])
if err: return err
err=validate_enum("new_tier", new_tier, "member_tier", optional=False) or validate_bool("allow_downgrade", allow_downgrade, optional=False)
if err: return err
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member is not active")
prev=member.get("tier")
if prev == new_tier: return error_response("TIER_UNCHANGED", "Requested tier equals current tier")
ranks=["classic","silver","gold","platinum"]
if ranks.index(new_tier) < ranks.index(prev) and not allow_downgrade: return error_response("DOWNGRADE_NOT_ALLOWED", "Downgrade requires allow_downgrade")
if new_tier in {"gold","platinum"} and float(member.get("lifetime_spend",0)) < TIER_MIN_SPEND[new_tier] and "service recovery" not in reason.lower(): return error_response("SPEND_PRECONDITION_FAILED", "Lifetime spend is too low for requested tier")
update(state_manager,"member",member_id,{"tier":new_tier,"updated_at":RUNTIME_NOW_ISO})
return success_response({"member_id":member_id,"previous_tier":prev,"new_tier":new_tier,"points_balance":member.get("points_balance"),"lifetime_spend":member.get("lifetime_spend"),"benefits":member_benefits(new_tier)})
def create_group_reservation(state_manager, venue_id=None, showtime_id=None, customer_name=None, customer_email=None, requested_seats=None, organizer_member_id=None, quote_amount=None, notes=""):
err=require_fields(locals(), ["venue_id","showtime_id","customer_name","customer_email","requested_seats"])
if err: return err
if not validate_email_address(customer_email): return error_response("INVALID_PARAMETER", "customer_email is invalid")
if not isinstance(requested_seats,int) or isinstance(requested_seats,bool) or requested_seats<10 or requested_seats>120: return error_response("OUT_OF_RANGE", "requested_seats must be 10 to 120")
if quote_amount is not None and (not isinstance(quote_amount,(int,float)) or quote_amount<0): return error_response("OUT_OF_RANGE", "quote_amount must be non-negative")
venue=get(state_manager,"venue",venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if venue.get("status") != "open": return error_response("VENUE_NOT_OPEN", "Venue is not open")
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("venue_id") != venue_id: return error_response("VENUE_SHOWTIME_MISMATCH", "Showtime belongs to another venue")
if showtime.get("status") not in {"scheduled","sales_open"}: return error_response("SHOWTIME_NOT_GROUP_BOOKABLE", "Showtime cannot accept group reservations")
if organizer_member_id:
member=get(state_manager,"member",organizer_member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Organizer member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Organizer member is not active")
if requested_seats > int(showtime.get("seats_available",0) or 0): return error_response("INSUFFICIENT_SEATS", "Not enough available seats")
quote=round(float(quote_amount) if quote_amount is not None else requested_seats*13.5,2); deposit=round(quote*0.3,2)
existing={g.get("group_reservation_id") for g in rows(state_manager,"group_reservation")}; base=f"group-{venue_id.removeprefix('venue-')}-{showtime.get('business_date')}-{slugify(customer_name)}"; idx=1; gid=f"{base}-{idx}"
while gid in existing: idx+=1; gid=f"{base}-{idx}"
group={"group_reservation_id":gid,"venue_id":venue_id,"organizer_member_id":organizer_member_id,"showtime_id":showtime_id,"customer_name":customer_name,"customer_email":customer_email,"requested_seats":requested_seats,"allocated_seat_ids":[],"status":"quoted" if quote_amount is not None else "requested","quote_amount":quote,"deposit_due":deposit,"deposit_paid":0.0,"booking_ids":[],"hold_ids":[],"notes":notes or "Group reservation created by operations.","created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"group_reservation",group)
return success_response({"group_reservation_id":gid,"status":group["status"],"venue_id":venue_id,"showtime_id":showtime_id,"requested_seats":requested_seats,"quote_amount":quote,"deposit_due":deposit})
def apply_booking_payment(state_manager, booking_id=None, payment_method=None, amount=None, processor_reference=None, mark_failed=False):
err=require_fields(locals(), ["booking_id","payment_method","amount","processor_reference"])
if err: return err
err=validate_enum("payment_method", payment_method, "payment_method", optional=False) or validate_bool("mark_failed", mark_failed, optional=False)
if err: return err
if not isinstance(amount,(int,float)) or isinstance(amount,bool) or amount<=0: return error_response("OUT_OF_RANGE", "amount must be positive")
if not isinstance(processor_reference,str) or not processor_reference.strip(): return error_response("INVALID_PARAMETER", "processor_reference is invalid")
booking=get(state_manager,"booking",booking_id)
if not booking: return error_response("BOOKING_NOT_FOUND", "Booking does not exist")
if booking.get("payment_status") not in {"unpaid","authorized"}: return error_response("BOOKING_NOT_PAYABLE", "Booking is not payable")
if abs(float(amount)-float(booking.get("total_amount",0))) > 0.01: return error_response("AMOUNT_MISMATCH", "Amount must match booking total")
if any(p.get("processor_reference")==processor_reference for p in rows(state_manager,"payment")): return error_response("DUPLICATE_PROCESSOR_REFERENCE", "Processor reference already exists")
showtime=get(state_manager,"showtime",booking.get("showtime_id")); venue_id=showtime.get("venue_id") if showtime else "venue-unknown"
member_point_delta=0
if payment_method == "member_points":
member=get(state_manager,"member",booking.get("member_id")) if booking.get("member_id") else None
needed=int(round(float(amount)*100))
if not member or member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member-points payment requires an active member")
if int(member.get("points_balance",0)) < needed: return error_response("INSUFFICIENT_POINTS", "Member lacks enough points")
status="failed" if mark_failed else "captured"
payment=create_payment(state_manager, booking_id=booking_id, venue_id=venue_id, amount=amount, method=payment_method, status=status, processor_reference=processor_reference)
booking_payment_status=booking.get("payment_status")
if not mark_failed:
update(state_manager,"booking",booking_id,{"status":"paid","payment_status":"captured","updated_at":RUNTIME_NOW_ISO}); booking_payment_status="captured"
if booking.get("member_id"):
member=get(state_manager,"member",booking["member_id"])
if member:
if payment_method == "member_points": member_point_delta=-int(round(float(amount)*100))
else: member_point_delta=int(round(float(amount)*10))
update(state_manager,"member",member["member_id"],{"points_balance":max(0,int(member.get("points_balance",0))+member_point_delta),"updated_at":RUNTIME_NOW_ISO})
return success_response({"payment_id":payment["payment_id"],"booking_id":booking_id,"payment_status":status,"booking_payment_status":booking_payment_status,"amount":round(float(amount),2),"member_point_delta":member_point_delta})
def assign_dynamic_pricing_plan(state_manager, showtime_id=None, pricing_plan_ids=None, mode="replace", reason=None):
err=require_fields(locals(), ["showtime_id","pricing_plan_ids","reason"])
if err: return err
err=validate_enum("mode", mode, "pricing_mode", optional=False)
if err: return err
if not isinstance(pricing_plan_ids,list) or not pricing_plan_ids or len(pricing_plan_ids)>10 or len(set(pricing_plan_ids))!=len(pricing_plan_ids): return error_response("OUT_OF_RANGE" if isinstance(pricing_plan_ids,list) and len(pricing_plan_ids)>10 else "INVALID_PARAMETER", "pricing_plan_ids must contain unique plan ids")
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("status") in {"completed","cancelled"}: return error_response("SHOWTIME_CLOSED", "Showtime is closed")
for pid in pricing_plan_ids:
plan=get(state_manager,"pricing_plan",pid)
if not plan: return error_response("PRICING_PLAN_NOT_FOUND", "Pricing plan does not exist")
if plan.get("status") != "active": return error_response("PRICING_PLAN_INACTIVE", "Pricing plan is inactive")
if plan.get("venue_id") != showtime.get("venue_id"): return error_response("PRICING_PLAN_VENUE_MISMATCH", "Pricing plan belongs to another venue")
issued=any(t.get("showtime_id")==showtime_id and t.get("status") in {"issued","checked_in"} for t in rows(state_manager,"ticket"))
if issued and mode in {"replace","remove"}: return error_response("ISSUED_TICKET_CONFLICT", "Issued tickets block replacing or removing pricing")
previous=list(showtime.get("pricing_plan_ids") or [])
if mode=="replace": new=list(pricing_plan_ids)
elif mode=="append": new=list(dict.fromkeys(previous+pricing_plan_ids))
else: new=[pid for pid in previous if pid not in pricing_plan_ids]
if not new: return error_response("ZERO_PRICING_PLANS", "Remove mode would leave no pricing plans")
update(state_manager,"showtime",showtime_id,{"pricing_plan_ids":new,"updated_at":RUNTIME_NOW_ISO})
return success_response({"showtime_id":showtime_id,"assignment_mode":mode,"previous_plan_ids":previous,"new_plan_ids":new,"added_ids":[p for p in new if p not in previous],"removed_ids":[p for p in previous if p not in new],"reason":reason})
def finalize_group_reservation(state_manager, group_reservation_id=None, seat_ids=None, capture_deposit=True, payment_method=None):
err=require_fields(locals(), ["group_reservation_id","seat_ids"])
if err: return err
err=validate_bool("capture_deposit", capture_deposit, optional=False) or validate_enum("payment_method", payment_method, "payment_method", optional=True)
if err: return err
if capture_deposit and not payment_method: return error_response("PAYMENT_METHOD_REQUIRED", "payment_method is required when capture_deposit is true")
group=get(state_manager,"group_reservation",group_reservation_id)
if not group: return error_response("GROUP_RESERVATION_NOT_FOUND", "Group reservation does not exist")
if group.get("status") not in {"quoted","confirmed"}: return error_response("GROUP_STATUS_NOT_FINALIZABLE", "Group status cannot be finalized")
if capture_deposit and float(group.get("deposit_paid",0) or 0)>0: return error_response("DEPOSIT_ALREADY_PAID", "Deposit is already paid")
venue=get(state_manager,"venue",group.get("venue_id"))
if not venue: return error_response("VENUE_NOT_FOUND", "Linked venue is missing")
showtime=get(state_manager,"showtime",group.get("showtime_id"))
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Linked showtime is missing")
if showtime.get("status") not in {"scheduled","sales_open"}: return error_response("SHOWTIME_NOT_GROUP_BOOKABLE", "Showtime cannot be finalized for group booking")
if not isinstance(seat_ids,list) or len(seat_ids)!=int(group.get("requested_seats",0)) or len(set(seat_ids))!=len(seat_ids): return error_response("SEAT_COUNT_MISMATCH", "Allocated seat count must equal requested seats")
err=validate_seat_selection(state_manager, showtime, seat_ids, max_count=120)
if err: return err
booking_id=build_booking_id(state_manager, showtime["venue_id"], group.get("customer_name"), showtime.get("business_date"))
total=round(float(group.get("quote_amount",0)),2)
booking={"booking_id":booking_id,"showtime_id":showtime["showtime_id"],"member_id":group.get("organizer_member_id"),"hold_id":None,"promo_code_id":None,"channel":"group_sales","customer_name":group.get("customer_name"),"customer_email":group.get("customer_email"),"status":"paid" if capture_deposit else "pending_payment","ticket_count":len(seat_ids),"subtotal":total,"discount_total":0.0,"service_fee_total":0.0,"total_amount":total,"payment_status":"captured" if capture_deposit else "unpaid","source_group_reservation_id":group_reservation_id,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO,"cancelled_at":None}
add(state_manager,"booking",booking); ticket_ids=[]
plan=(showtime.get("pricing_plan_ids") or [None])[0]
for seat_id in seat_ids:
tid=build_ticket_id(booking_id,seat_id); ticket_ids.append(tid)
add(state_manager,"ticket",{"ticket_id":tid,"booking_id":booking_id,"showtime_id":showtime["showtime_id"],"seat_id":seat_id,"pricing_plan_id":plan,"ticket_type":"standard","status":"issued","face_value":round(total/len(seat_ids),2),"discount_amount":0.0,"barcode":f"scan-{slugify(tid)}","checked_in_at":None,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO})
payment_id=None
deposit_paid=float(group.get("deposit_paid",0) or 0)
if capture_deposit:
amount=round(float(group.get("deposit_due",0)),2); payment=create_payment(state_manager, booking_id=booking_id, venue_id=showtime["venue_id"], amount=amount, method=payment_method, status="captured")
payment_id=payment["payment_id"]; deposit_paid=amount
if group.get("organizer_member_id"):
member=get(state_manager,"member",group["organizer_member_id"])
if member: update(state_manager,"member",member["member_id"],{"points_balance":int(member.get("points_balance",0))+int(amount*10),"updated_at":RUNTIME_NOW_ISO})
update(state_manager,"group_reservation",group_reservation_id,{"status":"ticketed","allocated_seat_ids":seat_ids,"booking_ids":[booking_id],"deposit_paid":deposit_paid,"updated_at":RUNTIME_NOW_ISO})
updated=recompute_showtime(state_manager, showtime["showtime_id"]); update(state_manager,"showtime",showtime["showtime_id"],{"revenue_gross":round(float(showtime.get("revenue_gross",0))+deposit_paid,2),"updated_at":RUNTIME_NOW_ISO})
updated=get(state_manager,"showtime",showtime["showtime_id"])
return success_response({"group_reservation_id":group_reservation_id,"booking_id":booking_id,"ticket_ids":ticket_ids,"payment_id":payment_id,"allocated_seat_count":len(seat_ids),"new_group_status":"ticketed","updated_showtime_availability":{"seats_sold":updated.get("seats_sold"),"seats_available":updated.get("seats_available")}})
def split_group_reservation(state_manager, group_reservation_id=None, split_seat_count=None, child_customer_name=None, child_customer_email=None, notes=""):
err=require_fields(locals(), ["group_reservation_id","split_seat_count","child_customer_name","child_customer_email"])
if err: return err
if not validate_email_address(child_customer_email): return error_response("INVALID_PARAMETER", "child_customer_email is invalid")
parent=get(state_manager,"group_reservation",group_reservation_id)
if not parent: return error_response("GROUP_RESERVATION_NOT_FOUND", "Parent group reservation does not exist")
if parent.get("status") in {"cancelled","ticketed"}: return error_response("GROUP_STATUS_NOT_SPLITTABLE", "Parent status cannot be split")
if parent.get("booking_ids"): return error_response("BOOKING_ALREADY_ISSUED", "Parent already has booking ids")
requested=int(parent.get("requested_seats",0))
if not isinstance(split_seat_count,int) or isinstance(split_seat_count,bool) or split_seat_count<5 or requested-split_seat_count<5: return error_response("OUT_OF_RANGE", "split_seat_count must be at least 5 and leave at least 5 seats")
parent_ratio=(requested-split_seat_count)/requested; child_ratio=split_seat_count/requested
parent_quote=round(float(parent.get("quote_amount",0))*parent_ratio,2); child_quote=round(float(parent.get("quote_amount",0))*child_ratio,2)
parent_deposit=round(float(parent.get("deposit_due",0))*parent_ratio,2); child_deposit=round(float(parent.get("deposit_due",0))*child_ratio,2)
if float(parent.get("deposit_paid",0) or 0)>parent_deposit and "manual adjustment" not in (notes or "").lower(): return error_response("DEPOSIT_CONFLICT", "Deposit paid would exceed retained parent deposit due")
existing={g.get("group_reservation_id") for g in rows(state_manager,"group_reservation")}; base=f"group-{parent.get('venue_id','venue').removeprefix('venue-')}-{(get(state_manager,'showtime',parent.get('showtime_id')) or {}).get('business_date','2026-05-27')}-{slugify(child_customer_name)}"; idx=1; child_id=f"{base}-{idx}"
while child_id in existing: idx+=1; child_id=f"{base}-{idx}"
update(state_manager,"group_reservation",group_reservation_id,{"requested_seats":requested-split_seat_count,"quote_amount":parent_quote,"deposit_due":parent_deposit,"notes":(parent.get("notes","")+" Split retained parent seats."),"updated_at":RUNTIME_NOW_ISO})
child=dict(parent); child.update({"group_reservation_id":child_id,"customer_name":child_customer_name,"customer_email":child_customer_email,"requested_seats":split_seat_count,"allocated_seat_ids":[],"quote_amount":child_quote,"deposit_due":child_deposit,"deposit_paid":0.0,"booking_ids":[],"hold_ids":[],"notes":notes or "Child group reservation from split.","created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO})
add(state_manager,"group_reservation",child)
return success_response({"parent_group_reservation_id":group_reservation_id,"child_group_reservation_id":child_id,"parent_requested_seats":requested-split_seat_count,"child_requested_seats":split_seat_count,"parent_quote_amount":parent_quote,"child_quote_amount":child_quote})
def change_showtime_auditorium(state_manager, showtime_id=None, new_auditorium_id=None, seat_mapping=None, cancel_unmapped=False, reason=None):
err=require_fields(locals(), ["showtime_id","new_auditorium_id","reason"])
if err: return err
seat_mapping = seat_mapping or []
err=validate_bool("cancel_unmapped", cancel_unmapped, optional=False)
if err: return err
if not isinstance(seat_mapping,list): return error_response("INVALID_PARAMETER", "seat_mapping must be a list")
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if showtime.get("status") not in {"scheduled","sales_open"} or not parse_datetime(showtime.get("starts_at")) or parse_datetime(showtime.get("starts_at")) <= RUNTIME_NOW: return error_response("SHOWTIME_NOT_MOVABLE", "Showtime is not movable")
aud=get(state_manager,"auditorium",new_auditorium_id)
if not aud: return error_response("AUDITORIUM_NOT_FOUND", "Target auditorium does not exist")
if aud.get("venue_id") != showtime.get("venue_id"): return error_response("AUDITORIUM_VENUE_MISMATCH", "Target auditorium belongs to another venue")
if aud.get("status") != "active": return error_response("AUDITORIUM_UNAVAILABLE", "Target auditorium is not active")
if aud.get("auditorium_id") == showtime.get("auditorium_id"): return error_response("AUDITORIUM_UNCHANGED", "Target auditorium is unchanged")
start=parse_datetime(showtime.get("starts_at")); end=parse_datetime(showtime.get("ends_at"))
for other in rows(state_manager,"showtime"):
if other.get("showtime_id")!=showtime_id and other.get("auditorium_id")==new_auditorium_id and other.get("status")!="cancelled":
os=parse_datetime(other.get("starts_at")); oe=parse_datetime(other.get("ends_at"))
if os and oe and start and end and not (end <= os or start >= oe): return error_response("SHOWTIME_OVERLAP", "Target auditorium has an overlapping showtime")
mapped={m.get("old_seat_id"):m.get("new_seat_id") for m in seat_mapping if isinstance(m,dict)}
if len(mapped)!=len(seat_mapping) or len(set(mapped.values()))!=len(mapped.values()): return error_response("SEAT_MAPPING_INVALID", "Seat mapping is invalid")
attached=list(issued_ticket_seats(state_manager,showtime_id)|active_hold_seats(state_manager,showtime_id))
if attached and not cancel_unmapped and any(seat not in mapped for seat in attached): return error_response("UNMAPPED_SEAT_CONFLICT", "Attached seats are unmapped")
for old,new in mapped.items():
old_seat=get(state_manager,"seat",old); new_seat=get(state_manager,"seat",new)
if not old_seat or old_seat.get("auditorium_id")!=showtime.get("auditorium_id") or not new_seat or new_seat.get("auditorium_id")!=new_auditorium_id or new_seat.get("status")!="available": return error_response("SEAT_MAPPING_INVALID", "Seat mapping references invalid seats")
remap_t=void_t=remap_h=rel_h=0
for ticket in rows(state_manager,"ticket"):
if ticket.get("showtime_id")==showtime_id and ticket.get("status") in {"issued","checked_in"}:
if ticket.get("seat_id") in mapped: update(state_manager,"ticket",ticket["ticket_id"],{"seat_id":mapped[ticket["seat_id"]],"updated_at":RUNTIME_NOW_ISO}); remap_t+=1
elif cancel_unmapped: update(state_manager,"ticket",ticket["ticket_id"],{"status":"voided","updated_at":RUNTIME_NOW_ISO}); void_t+=1
for hold in rows(state_manager,"seat_hold"):
if hold.get("showtime_id")==showtime_id and hold.get("status")=="active":
new_list=[]; release=False
for sid in hold.get("seat_ids") or []:
if sid in mapped: new_list.append(mapped[sid])
elif cancel_unmapped: release=True
else: new_list.append(sid)
if release and not new_list: update(state_manager,"seat_hold",hold["hold_id"],{"status":"released","updated_at":RUNTIME_NOW_ISO}); rel_h+=1
else: update(state_manager,"seat_hold",hold["hold_id"],{"seat_ids":new_list,"updated_at":RUNTIME_NOW_ISO}); remap_h+=1
update(state_manager,"showtime",showtime_id,{"auditorium_id":new_auditorium_id,"capacity":int(aud.get("capacity",0)),"updated_at":RUNTIME_NOW_ISO}); updated=recompute_showtime(state_manager,showtime_id)
return success_response({"showtime_id":showtime_id,"previous_auditorium_id":showtime.get("auditorium_id"),"new_auditorium_id":new_auditorium_id,"remapped_ticket_count":remap_t,"remapped_hold_count":remap_h,"voided_ticket_count":void_t,"released_hold_count":rel_h,"updated_availability":{"capacity":updated.get("capacity"),"seats_available":updated.get("seats_available")}})
def apply_membership_reward(state_manager, member_id=None, target_type=None, target_id=None, points_to_redeem=None, redemption_note=None):
err=require_fields(locals(), ["member_id","target_type","target_id","points_to_redeem","redemption_note"])
if err: return err
err=validate_enum("target_type", target_type, "target_type", optional=False)
if err: return err
if not isinstance(points_to_redeem,int) or isinstance(points_to_redeem,bool) or points_to_redeem<100 or points_to_redeem>50000: return error_response("OUT_OF_RANGE", "points_to_redeem must be 100 to 50000")
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
if member.get("status") != "active": return error_response("MEMBER_NOT_ACTIVE", "Member is not active")
if int(member.get("points_balance",0)) < points_to_redeem: return error_response("INSUFFICIENT_POINTS", "Member lacks enough points")
if target_type == "booking":
target=get(state_manager,"booking",target_id); entity="booking"
if not target: return error_response("TARGET_NOT_FOUND", "Booking target does not exist")
if target.get("member_id") != member_id: return error_response("MEMBER_TARGET_MISMATCH", "Target is not linked to member")
if target.get("status") not in {"pending_payment","paid"}: return error_response("TARGET_NOT_REDEEMABLE", "Booking cannot accept reward")
balance = float(target.get("total_amount",0)) if target.get("payment_status") != "captured" else float(target.get("total_amount",0))*0.5
venue_id=(get(state_manager,"showtime",target.get("showtime_id")) or {}).get("venue_id","venue-unknown")
else:
target=get(state_manager,"concession_order",target_id); entity="concession_order"
if not target: return error_response("TARGET_NOT_FOUND", "Concession order target does not exist")
if target.get("member_id") != member_id: return error_response("MEMBER_TARGET_MISMATCH", "Target is not linked to member")
if target.get("status") not in {"paid","preparing","ready"}: return error_response("TARGET_NOT_REDEEMABLE", "Concession order cannot accept reward")
balance=float(target.get("total_amount",0))*0.5; venue_id=target.get("venue_id")
redemption_amount=round(points_to_redeem/100.0,2)
if redemption_amount > balance: return error_response("REDEMPTION_EXCEEDS_BALANCE", "Redemption exceeds remaining payable balance")
update(state_manager,"member",member_id,{"points_balance":int(member.get("points_balance",0))-points_to_redeem,"updated_at":RUNTIME_NOW_ISO})
payment=create_payment(state_manager, booking_id=target_id if target_type=="booking" else None, order_id=target_id if target_type=="concession_order" else None, venue_id=venue_id, amount=redemption_amount, method="member_points", status="captured")
remaining=round(max(0,balance-redemption_amount),2)
if target_type=="booking" and remaining==0: update(state_manager,"booking",target_id,{"payment_status":"captured","status":"paid","updated_at":RUNTIME_NOW_ISO})
return success_response({"member_id":member_id,"payment_id":payment["payment_id"],"target_type":target_type,"target_id":target_id,"redeemed_points":points_to_redeem,"redemption_amount":redemption_amount,"remaining_target_balance":remaining,"new_points_balance":int(member.get("points_balance",0))-points_to_redeem})
def close_daily_box_office(state_manager, venue_id=None, business_date=None, closed_by=None, force_recompute=False):
err=require_fields(locals(), ["venue_id","business_date","closed_by"])
if err: return err
day=parse_date(business_date)
if not day or day > RUNTIME_NOW: return error_response("INVALID_DATE", "business_date is malformed or future")
err=validate_bool("force_recompute", force_recompute, optional=False)
if err: return err
if not isinstance(closed_by,str) or not closed_by.strip(): return error_response("INVALID_PARAMETER", "closed_by is invalid")
venue=get(state_manager,"venue",venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
box=next((d for d in rows(state_manager,"box_office_day") if d.get("venue_id")==venue_id and d.get("business_date")==business_date),None)
if not box: return error_response("BOX_DAY_NOT_FOUND", "Box office day does not exist")
if box.get("status") in {"closed","audited"} and not force_recompute: return error_response("BOX_DAY_ALREADY_CLOSED", "Day is already closed or audited")
showtime_ids={s["showtime_id"] for s in rows(state_manager,"showtime") if s.get("venue_id")==venue_id and s.get("business_date")==business_date}
if any(b.get("showtime_id") in showtime_ids and b.get("payment_status")=="unpaid" for b in rows(state_manager,"booking")): return error_response("PENDING_BOOKING_CONFLICT", "Same-day booking remains pending")
if any(o.get("venue_id")==venue_id and str(o.get("created_at",''))[:10]==business_date and o.get("status") in {"preparing","ready"} for o in rows(state_manager,"concession_order")) and not force_recompute: return error_response("OPEN_CONCESSION_ORDER_CONFLICT", "Same-day concession order remains open")
pays=[p for p in rows(state_manager,"payment") if p.get("venue_id")==venue_id and str(p.get("processed_at",''))[:10]==business_date]
if any(p.get("status")=="captured" and not p.get("processor_reference") for p in pays): return error_response("UNSETTLED_PAYMENT_CONFLICT", "Captured payment lacks processor reference")
ticket_sales=round(sum(float(p.get("amount",0)) for p in pays if p.get("booking_id") and p.get("status")=="captured"),2)
concession_sales=round(sum(float(p.get("amount",0)) for p in pays if p.get("order_id") and p.get("status")=="captured"),2)
refunds=round(sum(float(p.get("amount",0)) for p in pays if p.get("status")=="refunded"),2)
tickets_sold=sum(1 for t in rows(state_manager,"ticket") if t.get("showtime_id") in showtime_ids and t.get("status") in {"issued","checked_in"})
orders_count=sum(1 for o in rows(state_manager,"concession_order") if o.get("venue_id")==venue_id and str(o.get("created_at",''))[:10]==business_date)
previous={k:box.get(k) for k in ["gross_ticket_sales","gross_concession_sales","refunds_total","tickets_sold","orders_count","payments_count"]}
patch={"status":"closed","gross_ticket_sales":ticket_sales,"gross_concession_sales":concession_sales,"refunds_total":refunds,"taxes_total":round(concession_sales*0.0825,2),"tickets_sold":tickets_sold,"orders_count":orders_count,"payments_count":len(pays),"closed_by":closed_by,"closed_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
update(state_manager,"box_office_day",box["box_office_day_id"],patch); new=dict(box); new.update(patch)
deltas={k:round(float(new.get(k,0))-float(previous.get(k,0) or 0),2) for k in previous}
return success_response({"box_office_day_id":box["box_office_day_id"],"venue_id":venue_id,"business_date":business_date,"status":"closed","summary":{k:new[k] for k in ["gross_ticket_sales","gross_concession_sales","refunds_total","taxes_total","tickets_sold","orders_count","payments_count"]},"reconciliation_deltas":deltas,"closed_at":RUNTIME_NOW_ISO})
def refresh_loyalty_balances(state_manager, member_id=None, venue_id=None, dry_run=False, max_members=100):
if not member_id and not venue_id: return error_response("MISSING_SCOPE", "member_id or venue_id is required")
err=validate_bool("dry_run", dry_run, optional=False) or validate_int_range("max_members", max_members, 1, 500)
if err: return err
selected=[]
if member_id:
member=get(state_manager,"member",member_id)
if not member: return error_response("MEMBER_NOT_FOUND", "Member does not exist")
selected=[member]
if venue_id:
venue=get(state_manager,"venue",venue_id)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if member_id and selected[0].get("home_venue_id") != venue_id: return error_response("MEMBER_VENUE_MISMATCH", "Member home venue differs from requested venue")
if not member_id: selected=[m for m in rows(state_manager,"member") if m.get("home_venue_id")==venue_id][:max_members]
if any(m.get("status")=="fraud_review" for m in selected): return error_response("MEMBER_IN_REVIEW", "Fraud-review members cannot be automatically adjusted")
diffs=[]; point_delta=0; tier_changes=[]
for m in selected:
expected_points, expected_spend, expected_tier = recompute_member_expected(state_manager,m)
diff={"member_id":m["member_id"],"previous_points":m.get("points_balance"),"new_points":expected_points,"previous_tier":m.get("tier"),"new_tier":expected_tier,"previous_lifetime_spend":m.get("lifetime_spend"),"new_lifetime_spend":expected_spend}
if diff["previous_points"]!=expected_points or diff["previous_tier"]!=expected_tier or round(float(diff["previous_lifetime_spend"]),2)!=expected_spend:
diffs.append(diff); point_delta += expected_points-int(m.get("points_balance",0))
if m.get("tier")!=expected_tier: tier_changes.append({"member_id":m["member_id"],"previous_tier":m.get("tier"),"new_tier":expected_tier})
if not dry_run: update(state_manager,"member",m["member_id"],{"points_balance":expected_points,"lifetime_spend":expected_spend,"tier":expected_tier,"updated_at":RUNTIME_NOW_ISO})
return success_response({"scope":{"member_id":member_id,"venue_id":venue_id},"dry_run":dry_run,"members_scanned":len(selected),"members_changed":len(diffs),"point_delta":point_delta,"tier_changes":tier_changes,"diffs":diffs[:max_members]})
def launch_promo_code(state_manager, code=None, venue_ids=None, name=None, discount_type=None, discount_value=None, max_redemptions=None, start_at=None, end_at=None, applies_to=None):
err=require_fields(locals(), ["code","venue_ids","name","discount_type","discount_value","max_redemptions","start_at","end_at","applies_to"])
if err: return err
if not isinstance(code,str) or not re.match(r"^[A-Za-z0-9-]+$", code): return error_response("INVALID_PARAMETER", "code must be alphanumeric with optional hyphens")
err=validate_enum("discount_type", discount_type, "discount_type", optional=False) or validate_enum("applies_to", applies_to, "applies_to", optional=False)
if err: return err
if not isinstance(venue_ids,list) or not venue_ids or len(venue_ids)>20 or len(set(venue_ids))!=len(venue_ids): return error_response("OUT_OF_RANGE" if isinstance(venue_ids,list) and len(venue_ids)>20 else "INVALID_PARAMETER", "venue_ids must contain unique venue ids")
if discount_type == "percent" and (not isinstance(discount_value,(int,float)) or discount_value<=0 or discount_value>50): return error_response("OUT_OF_RANGE", "percent discount must be greater than zero and at most 50")
if discount_type == "fixed" and (not isinstance(discount_value,(int,float)) or discount_value<=0 or discount_value>100): return error_response("OUT_OF_RANGE", "fixed discount must be greater than zero and at most 100")
if not isinstance(max_redemptions,int) or max_redemptions<1 or max_redemptions>100000: return error_response("OUT_OF_RANGE", "max_redemptions must be 1 to 100000")
start=parse_datetime(start_at); end=parse_datetime(end_at)
if not start or not end: return error_response("INVALID_PARAMETER", "start_at and end_at must be ISO datetimes")
if start >= end: return error_response("INVALID_DATE_RANGE", "start_at must be before end_at")
if any(p.get("code","").lower()==code.lower() for p in rows(state_manager,"promo_code")): return error_response("DUPLICATE_PROMO_CODE", "Promo code already exists")
for vid in venue_ids:
venue=get(state_manager,"venue",vid)
if not venue: return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if venue.get("status") != "open": return error_response("VENUE_NOT_OPEN", "Venue is not open")
existing={p.get("promo_code_id") for p in rows(state_manager,"promo_code")}; base=f"promo-{venue_ids[0].removeprefix('venue-')}-{slugify(name)}"; idx=1; pid=f"{base}-{idx}"
while pid in existing: idx+=1; pid=f"{base}-{idx}"
status="scheduled" if start > RUNTIME_NOW else "active"
promo={"promo_code_id":pid,"code":code.upper(),"venue_ids":venue_ids,"name":name,"discount_type":discount_type,"discount_value":float(discount_value),"max_redemptions":max_redemptions,"redeemed_count":0,"start_at":isoformat_z(start),"end_at":isoformat_z(end),"status":status,"applies_to":applies_to,"created_at":RUNTIME_NOW_ISO,"updated_at":RUNTIME_NOW_ISO}
add(state_manager,"promo_code",promo)
return success_response({k:promo.get(k) for k in ["promo_code_id","code","status","venue_ids","discount_type","discount_value","max_redemptions","start_at","end_at"]})
def expire_stale_holds(state_manager, as_of=None, venue_id=None, showtime_id=None, max_holds=100, dry_run=False):
err=require_one("as_of", as_of, "MISSING_FIELD")
if err: return err
cutoff=parse_datetime(as_of)
if not cutoff: return error_response("INVALID_PARAMETER", "as_of must be an ISO datetime")
err=validate_int_range("max_holds", max_holds, 1, 1000) or validate_bool("dry_run", dry_run, optional=False)
if err: return err
if venue_id and not get(state_manager,"venue",venue_id): return error_response("VENUE_NOT_FOUND", "Venue does not exist")
if showtime_id:
showtime=get(state_manager,"showtime",showtime_id)
if not showtime: return error_response("SHOWTIME_NOT_FOUND", "Showtime does not exist")
if venue_id and showtime.get("venue_id") != venue_id: return error_response("VENUE_SHOWTIME_MISMATCH", "Showtime belongs to another venue")
candidates=[]
for hold in rows(state_manager,"seat_hold"):
if hold.get("status")!="active": continue
st=get(state_manager,"showtime",hold.get("showtime_id"))
if venue_id and (not st or st.get("venue_id")!=venue_id): continue
if showtime_id and hold.get("showtime_id")!=showtime_id: continue
exp=parse_datetime(hold.get("expires_at"))
if exp and exp <= cutoff: candidates.append((exp,hold))
selected=[h for _,h in sorted(candidates,key=lambda item:item[0])[:max_holds]]
affected={}
for hold in selected:
before=get(state_manager,"showtime",hold["showtime_id"])
affected.setdefault(hold["showtime_id"],{"showtime_id":hold["showtime_id"],"released_seats":0,"previous_seats_available": before.get("seats_available") if before else None})
affected[hold["showtime_id"]]["released_seats"] += len(hold.get("seat_ids") or [])
if not dry_run: update(state_manager,"seat_hold",hold["hold_id"],{"status":"expired","updated_at":RUNTIME_NOW_ISO})
if not dry_run:
for sid in affected:
updated=recompute_showtime(state_manager,sid); affected[sid]["new_seats_available"]=updated.get("seats_available") if updated else None
else:
for sid,info in affected.items(): info["new_seats_available"]=None
return success_response({"dry_run":dry_run,"expired_hold_ids":[h["hold_id"] for h in selected],"expired_hold_count":len(selected),"released_seat_count":sum(len(h.get("seat_ids") or []) for h in selected),"affected_showtimes":list(affected.values())})