Download cases/cinema/raw/mcp_servers/tool_impl.py from JoeYing/ReScopeBench: direct link, hf CLI and curl.
- Browser
- Download file 87.6 kB
-
https://huggingface.co/datasets/JoeYing/ReScopeBench/resolve/main/cases/cinema/raw/mcp_servers/tool_impl.py
- Command line
-
hf download hf://datasets/JoeYing/ReScopeBench/cases/cinema/raw/mcp_servers/tool_impl.py
-
curl -L -o tool_impl.py https://huggingface.co/datasets/JoeYing/ReScopeBench/resolve/main/cases/cinema/raw/mcp_servers/tool_impl.py
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())}) | |