art-dag/mono
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refine events + sx sub-module imports from background agents

Browse Source 
Events: route imports now point to specific sub-modules (entries,
tickets, slots) instead of all going through renders.py. Merged
layouts into helpers.py. __init__.py now 20 lines.

SX Docs: moved dispatchers from helpers.py into essays.py, cleaned
up __init__.py to 24 lines.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
giles
2026-03-04 17:13:45 +00:00
parent 5344b382a5
commit ad6a8ecb17
18 changed files with 446 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
events/bp/all_events/routes.py
View File

@@ -125,7 +125,7 @@ def register() -> Blueprint:
if ident["session_id"] is not None:
frag_params["session_id"] = ident["session_id"]
from sxc.pages.renders import render_ticket_widget
from sxc.pages.tickets import render_ticket_widget
widget_html = await render_ticket_widget(entry, qty, "/all-tickets/adjust")
mini_html = await fetch_fragment("cart", "cart-mini", params=frag_params, required=False)
return sx_response(widget_html + (mini_html or ""))

2
events/bp/calendar/routes.py
View File

@@ -224,7 +224,7 @@ def register():
if post_data:
from shared.services.entry_associations import get_associated_entries
from sxc.pages.renders import render_post_nav_entries_oob
from sxc.pages.entries import render_post_nav_entries_oob
post_id = (post_data.get("post") or {}).get("id")
cals = (

4
events/bp/calendar_entries/routes.py
View File

@@ -279,12 +279,12 @@ def register():
result = await g.s.execute(stmt)
day_slots = list(result.scalars())
from sxc.pages.renders import render_entry_add_form
from sxc.pages.entries import render_entry_add_form
return sx_response(await render_entry_add_form(g.calendar, day, month, year, day_slots))
@bp.get("/add-button/")
async def add_button(day: int, month: int, year: int, **kwargs):
from sxc.pages.renders import render_entry_add_button
from sxc.pages.entries import render_entry_add_button
return sx_response(await render_entry_add_button(g.calendar, day, month, year))

20
events/bp/calendar_entry/routes.py
View File

@@ -111,7 +111,7 @@ def register():
)
# Render OOB nav
from sxc.pages.renders import render_day_entries_nav_oob
from sxc.pages.entries import render_day_entries_nav_oob
return await render_day_entries_nav_oob(visible.confirmed_entries, calendar, day_date)
async def get_post_nav_oob(entry_id: int):
@@ -148,7 +148,7 @@ def register():
).scalars().all()
# Render OOB nav for this post
from sxc.pages.renders import render_post_nav_entries_oob
from sxc.pages.entries import render_post_nav_entries_oob
nav_oob = await render_post_nav_entries_oob(associated_entries, calendars, post)
nav_oobs.append(nav_oob)
@@ -256,7 +256,7 @@ def register():
result = await g.s.execute(stmt)
day_slots = list(result.scalars())
from sxc.pages.renders import render_entry_edit_form
from sxc.pages.entries import render_entry_edit_form
return sx_response(await render_entry_edit_form(g.entry, g.calendar, day, month, year, day_slots))
@bp.put("/")
@@ -448,7 +448,7 @@ def register():
# Re-read entry to get updated state
await g.s.refresh(g.entry)
from sxc.pages.renders import render_entry_optioned
from sxc.pages.entries import render_entry_optioned
html = await render_entry_optioned(g.entry, g.calendar, day, month, year)
return sx_response(html + day_nav_oob + post_nav_oob)
@@ -473,7 +473,7 @@ def register():
# Re-read entry to get updated state
await g.s.refresh(g.entry)
from sxc.pages.renders import render_entry_optioned
from sxc.pages.entries import render_entry_optioned
html = await render_entry_optioned(g.entry, g.calendar, day, month, year)
return sx_response(html + day_nav_oob + post_nav_oob)
@@ -498,7 +498,7 @@ def register():
# Re-read entry to get updated state
await g.s.refresh(g.entry)
from sxc.pages.renders import render_entry_optioned
from sxc.pages.entries import render_entry_optioned
html = await render_entry_optioned(g.entry, g.calendar, day, month, year)
return sx_response(html + day_nav_oob + post_nav_oob)
@@ -542,7 +542,7 @@ def register():
# Return just the tickets fragment (targeted by hx-target="#entry-tickets-...")
await g.s.refresh(g.entry)
from sxc.pages.renders import render_entry_tickets_config
from sxc.pages.entries import render_entry_tickets_config
html = await render_entry_tickets_config(g.entry, g.calendar, request.view_args.get("day"), request.view_args.get("month"), request.view_args.get("year"))
return sx_response(html)
@@ -558,7 +558,7 @@ def register():
total_pages = math.ceil(total / per_page) if total > 0 else 0
va = request.view_args or {}
from sxc.pages.renders import render_post_search_results
from sxc.pages.entries import render_post_search_results
return sx_response(await render_post_search_results(
search_posts, query, page, total_pages,
g.entry, g.calendar,
@@ -592,7 +592,7 @@ def register():
entry_posts = await get_entry_posts(g.s, entry_id)
# Return updated posts list + OOB nav update
from sxc.pages.renders import render_entry_posts_panel, render_entry_posts_nav_oob
from sxc.pages.entries import render_entry_posts_panel, render_entry_posts_nav_oob
va = request.view_args or {}
html = await render_entry_posts_panel(entry_posts, g.entry, g.calendar, va.get("day"), va.get("month"), va.get("year"))
nav_oob = await render_entry_posts_nav_oob(entry_posts)
@@ -614,7 +614,7 @@ def register():
entry_posts = await get_entry_posts(g.s, entry_id)
# Return updated posts list + OOB nav update
from sxc.pages.renders import render_entry_posts_panel, render_entry_posts_nav_oob
from sxc.pages.entries import render_entry_posts_panel, render_entry_posts_nav_oob
va = request.view_args or {}
html = await render_entry_posts_panel(entry_posts, g.entry, g.calendar, va.get("day"), va.get("month"), va.get("year"))
nav_oob = await render_entry_posts_nav_oob(entry_posts)

2
events/bp/calendars/routes.py
View File

@@ -74,7 +74,7 @@ def register():
# Blog-embedded mode: also update post nav
if post_data:
from shared.services.entry_associations import get_associated_entries
from sxc.pages.renders import render_post_nav_entries_oob
from sxc.pages.entries import render_post_nav_entries_oob
cals = (
await g.s.execute(

2
events/bp/page/routes.py
View File

@@ -106,7 +106,7 @@ def register() -> Blueprint:
if ident["session_id"] is not None:
frag_params["session_id"] = ident["session_id"]
from sxc.pages.renders import render_ticket_widget
from sxc.pages.tickets import render_ticket_widget
widget_html = await render_ticket_widget(entry, qty, f"/{g.post_slug}/tickets/adjust")
mini_html = await fetch_fragment("cart", "cart-mini", params=frag_params, required=False)
return sx_response(widget_html + (mini_html or ""))

8
events/bp/slot/routes.py
View File

@@ -35,7 +35,7 @@ def register():
slot = await svc_get_slot(g.s, slot_id)
if not slot:
return await make_response("Not found", 404)
from sxc.pages.renders import render_slot_edit_form
from sxc.pages.slots import render_slot_edit_form
return sx_response(await render_slot_edit_form(slot, g.calendar))
@bp.get("/view/")
@@ -44,7 +44,7 @@ def register():
slot = await svc_get_slot(g.s, slot_id)
if not slot:
return await make_response("Not found", 404)
from sxc.pages.renders import render_slot_main_panel
from sxc.pages.slots import render_slot_main_panel
return sx_response(await render_slot_main_panel(slot, g.calendar))
@bp.delete("/")
@@ -53,7 +53,7 @@ def register():
async def slot_delete(slot_id: int, **kwargs):
await svc_delete_slot(g.s, slot_id)
slots = await svc_list_slots(g.s, g.calendar.id)
from sxc.pages.renders import render_slots_table
from sxc.pages.slots import render_slots_table
return sx_response(await render_slots_table(slots, g.calendar))
@bp.put("/")
@@ -135,7 +135,7 @@ def register():
}
), 422
from sxc.pages.renders import render_slot_main_panel
from sxc.pages.slots import render_slot_main_panel
return sx_response(await render_slot_main_panel(slot, g.calendar, oob=True))

6
events/bp/slots/routes.py
View File

@@ -110,20 +110,20 @@ def register():
# Success → re-render the slots table
slots = await svc_list_slots(g.s, g.calendar.id)
from sxc.pages.renders import render_slots_table
from sxc.pages.slots import render_slots_table
return sx_response(await render_slots_table(slots, g.calendar))
@bp.get("/add")
@require_admin
async def add_form(**kwargs):
from sxc.pages.renders import render_slot_add_form
from sxc.pages.slots import render_slot_add_form
return sx_response(await render_slot_add_form(g.calendar))
@bp.get("/add-button")
@require_admin
async def add_button(**kwargs):
from sxc.pages.renders import render_slot_add_button
from sxc.pages.slots import render_slot_add_button
return sx_response(await render_slot_add_button(g.calendar))
return bp

6
events/bp/ticket_admin/routes.py
View File

@@ -53,7 +53,7 @@ def register() -> Blueprint:
tickets = await get_tickets_for_entry(g.s, entry_id)
from sxc.pages.renders import render_entry_tickets_admin
from sxc.pages.tickets import render_entry_tickets_admin
html = await render_entry_tickets_admin(entry, tickets)
return sx_response(html)
@@ -69,7 +69,7 @@ def register() -> Blueprint:
)
ticket = await get_ticket_by_code(g.s, code)
from sxc.pages.renders import render_lookup_result
from sxc.pages.tickets import render_lookup_result
if not ticket:
return sx_response(await render_lookup_result(None, "Ticket not found"))
@@ -82,7 +82,7 @@ def register() -> Blueprint:
"""Check in a ticket by its code."""
success, error = await checkin_ticket(g.s, code)
from sxc.pages.renders import render_checkin_result
from sxc.pages.tickets import render_checkin_result
if not success:
return sx_response(await render_checkin_result(False, error, None))

8
events/bp/ticket_type/routes.py
View File

@@ -30,7 +30,7 @@ def register():
if not ticket_type:
return await make_response("Not found", 404)
from sxc.pages.renders import render_ticket_type_edit_form
from sxc.pages.tickets import render_ticket_type_edit_form
va = request.view_args or {}
return sx_response(await render_ticket_type_edit_form(
ticket_type, g.entry, g.calendar,
@@ -45,7 +45,7 @@ def register():
if not ticket_type:
return await make_response("Not found", 404)
from sxc.pages.renders import render_ticket_type_main_panel
from sxc.pages.tickets import render_ticket_type_main_panel
va = request.view_args or {}
return sx_response(await render_ticket_type_main_panel(
ticket_type, g.entry, g.calendar,
@@ -112,7 +112,7 @@ def register():
return await make_response("Not found", 404)
# Return updated view with OOB flag
from sxc.pages.renders import render_ticket_type_main_panel
from sxc.pages.tickets import render_ticket_type_main_panel
va = request.view_args or {}
return sx_response(await render_ticket_type_main_panel(
ticket_type, g.entry, g.calendar,
@@ -131,7 +131,7 @@ def register():
# Re-render the ticket types list
ticket_types = await svc_list_ticket_types(g.s, g.entry.id)
from sxc.pages.renders import render_ticket_types_table
from sxc.pages.tickets import render_ticket_types_table
va = request.view_args or {}
return sx_response(await render_ticket_types_table(
ticket_types, g.entry, g.calendar,

6
events/bp/ticket_types/routes.py
View File

@@ -93,7 +93,7 @@ def register():
# Success → re-render the ticket types table
ticket_types = await svc_list_ticket_types(g.s, g.entry.id)
from sxc.pages.renders import render_ticket_types_table
from sxc.pages.tickets import render_ticket_types_table
va = request.view_args or {}
return sx_response(await render_ticket_types_table(
ticket_types, g.entry, g.calendar,
@@ -104,7 +104,7 @@ def register():
@require_admin
async def add_form(**kwargs):
"""Show the add ticket type form."""
from sxc.pages.renders import render_ticket_type_add_form
from sxc.pages.tickets import render_ticket_type_add_form
va = request.view_args or {}
return sx_response(await render_ticket_type_add_form(
g.entry, g.calendar,
@@ -115,7 +115,7 @@ def register():
@require_admin
async def add_button(**kwargs):
"""Show the add ticket type button."""
from sxc.pages.renders import render_ticket_type_add_button
from sxc.pages.tickets import render_ticket_type_add_button
va = request.view_args or {}
return sx_response(await render_ticket_type_add_button(
g.entry, g.calendar,

4
events/bp/tickets/routes.py
View File

@@ -126,7 +126,7 @@ def register() -> Blueprint:
summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
cart_count = summary.count + summary.calendar_count + summary.ticket_count
from sxc.pages.renders import render_buy_result
from sxc.pages.tickets import render_buy_result
return sx_response(await render_buy_result(entry, created, remaining, cart_count))
@bp.post("/adjust/")
@@ -249,7 +249,7 @@ def register() -> Blueprint:
summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
cart_count = summary.count + summary.calendar_count + summary.ticket_count
from sxc.pages.renders import render_adjust_response
from sxc.pages.tickets import render_adjust_response
return sx_response(await render_adjust_response(
entry, ticket_remaining, ticket_sold_count,
user_ticket_count, user_ticket_counts_by_type, cart_count,

7
events/sxc/pages/__init__.py
View File

@@ -4,8 +4,7 @@ from __future__ import annotations
def setup_events_pages() -> None:
"""Register events-specific layouts, page helpers, and load page definitions."""
from .layouts import _register_events_layouts
from .helpers import _register_events_helpers
from .helpers import _register_events_layouts, _register_events_helpers
_register_events_layouts()
_register_events_helpers()
_load_events_page_files()
@@ -15,7 +14,7 @@ def _load_events_page_files() -> None:
import os
from shared.sx.pages import load_page_dir
from shared.sx.jinja_bridge import load_service_components
sxc_dir = os.path.dirname(os.path.dirname(__file__))
service_root = os.path.dirname(sxc_dir)
sxc_dir = os.path.dirname(os.path.dirname(__file__)) # events/sxc/
service_root = os.path.dirname(sxc_dir) # events/
load_service_components(service_root, service_name="events")
load_page_dir(os.path.dirname(__file__), "events")

2
events/sxc/pages/entries.py
View File

@@ -210,7 +210,7 @@ async def _entry_main_panel_html(ctx: dict) -> str:
"""Render the entry detail panel (name, slot, time, state, cost, tickets,
buy form, date, posts, options + edit button)."""
from quart import url_for
from .tickets import render_buy_form, render_entry_tickets_config
from .tickets import render_buy_form
entry = ctx.get("entry")
if not entry:

315
events/sxc/pages/helpers.py
View File

@@ -1,8 +1,35 @@
"""Page helpers — _h_* helper functions + _register_events_helpers + _ensure_* context hydration."""
"""Layout registrations, page helpers, and shared hydration helpers."""
from __future__ import annotations
from typing import Any
from shared.sx.helpers import render_to_sx
from .utils import _clear_deeper_oob, _ensure_container_nav
from .calendar import (
_post_header_sx, _calendar_header_sx,
_calendar_admin_header_sx, _day_header_sx,
_day_admin_header_sx, _markets_header_sx,
_calendars_main_panel_sx,
_calendar_admin_main_panel_html,
_day_admin_main_panel_html,
_markets_main_panel_html,
)
from .entries import (
_entry_header_html, _entry_main_panel_html,
_entry_nav_html,
_entry_admin_header_html, _entry_admin_main_panel_html,
)
from .tickets import (
_tickets_main_panel_html, _ticket_detail_panel_html,
_ticket_admin_main_panel_html,
_ticket_types_header_html, _ticket_type_header_html,
render_ticket_type_main_panel, render_ticket_types_table,
)
from .slots import (
_slot_header_html, render_slot_main_panel, render_slots_table,
)
# ---------------------------------------------------------------------------
# Shared hydration helpers
@@ -181,6 +208,279 @@ async def _ensure_day_data(year: int, month: int, day: int) -> None:
)
# ---------------------------------------------------------------------------
# Layouts
# ---------------------------------------------------------------------------
def _register_events_layouts() -> None:
from shared.sx.layouts import register_custom_layout
register_custom_layout("events-calendar-admin", _cal_admin_full, _cal_admin_oob)
register_custom_layout("events-slots", _slots_full, _slots_oob)
register_custom_layout("events-slot", _slot_full, _slot_oob)
register_custom_layout("events-day-admin", _day_admin_full, _day_admin_oob)
register_custom_layout("events-entry", _entry_full, _entry_oob)
register_custom_layout("events-entry-admin", _entry_admin_full, _entry_admin_oob)
register_custom_layout("events-ticket-types", _ticket_types_full, _ticket_types_oob)
register_custom_layout("events-ticket-type", _ticket_type_full, _ticket_type_oob)
register_custom_layout("events-markets", _markets_full, _markets_oob)
# --- Calendar admin layout (root + post + child(post-admin + calendar + cal-admin)) ---
async def _cal_admin_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-cal-admin-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
calendar_admin_header=SxExpr(await _calendar_admin_header_sx(ctx)),
)
async def _cal_admin_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx, oob_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-cal-admin-layout-oob", _ctx_to_env(ctx, oob=True),
admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
cal_oob=SxExpr(await _calendar_header_sx(ctx, oob=True)),
cal_admin_oob_wrap=SxExpr(await oob_header_sx("calendar-header-child",
"calendar-admin-header-child", await _calendar_admin_header_sx(ctx))),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"post-admin-row", "post-admin-header-child",
"calendar-row", "calendar-header-child",
"calendar-admin-row", "calendar-admin-header-child")),
)
# --- Slots layout (same full as cal-admin but different OOB) ---
async def _slots_full(ctx: dict, **kw: Any) -> str:
return await _cal_admin_full({**ctx, "is_admin_section": True}, **kw)
async def _slots_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-slots-layout-oob", _ctx_to_env(ctx, oob=True),
admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
cal_admin_oob=SxExpr(await _calendar_admin_header_sx(ctx, oob=True)),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"post-admin-row", "post-admin-header-child",
"calendar-row", "calendar-header-child",
"calendar-admin-row", "calendar-admin-header-child")),
)
# --- Slot detail layout (extends cal-admin with slot header) ---
async def _slot_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-slot-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
calendar_admin_header=SxExpr(await _calendar_admin_header_sx(ctx)),
slot_header=SxExpr(await _slot_header_html(ctx)),
)
async def _slot_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx, oob_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-slot-layout-oob", _ctx_to_env(ctx, oob=True),
admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
cal_admin_oob=SxExpr(await _calendar_admin_header_sx(ctx, oob=True)),
slot_oob_wrap=SxExpr(await oob_header_sx("calendar-admin-header-child",
"slot-header-child", await _slot_header_html(ctx))),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"post-admin-row", "post-admin-header-child",
"calendar-row", "calendar-header-child",
"calendar-admin-row", "calendar-admin-header-child",
"slot-row", "slot-header-child")),
)
# --- Day admin layout (root + post + post-admin + child(cal + day + day-admin)) ---
async def _day_admin_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-day-admin-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
day_header=SxExpr(await _day_header_sx(ctx)),
day_admin_header=SxExpr(await _day_admin_header_sx(ctx)),
)
async def _day_admin_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx, oob_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-day-admin-layout-oob", _ctx_to_env(ctx, oob=True),
admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
cal_oob=SxExpr(await _calendar_header_sx(ctx, oob=True)),
day_admin_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
"day-admin-header-child", await _day_admin_header_sx(ctx))),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"post-admin-row", "post-admin-header-child",
"calendar-row", "calendar-header-child",
"day-row", "day-header-child",
"day-admin-row", "day-admin-header-child")),
)
# --- Entry layout (root + child(post + cal + day + entry), + menu) ---
async def _entry_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-entry-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
day_header=SxExpr(await _day_header_sx(ctx)),
entry_header=SxExpr(await _entry_header_html(ctx)),
)
async def _entry_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, oob_header_sx
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-entry-layout-oob", _ctx_to_env(ctx, oob=True),
day_oob=SxExpr(await _day_header_sx(ctx, oob=True)),
entry_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
"entry-header-child", await _entry_header_html(ctx))),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"calendar-row", "calendar-header-child",
"day-row", "day-header-child",
"entry-row", "entry-header-child")),
)
# --- Entry admin layout (root + post + child(post-admin + cal + day + entry + entry-admin), + menu) ---
async def _entry_admin_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-entry-admin-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
day_header=SxExpr(await _day_header_sx(ctx)),
entry_header=SxExpr(await _entry_header_html(ctx)),
entry_admin_header=SxExpr(await _entry_admin_header_html(ctx)),
)
async def _entry_admin_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, post_admin_header_sx, oob_header_sx
from shared.sx.parser import SxExpr
ctx = await _ensure_container_nav(ctx)
slug = (ctx.get("post") or {}).get("slug", "")
return await render_to_sx_with_env("events-entry-admin-layout-oob", _ctx_to_env(ctx, oob=True),
admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
entry_oob=SxExpr(await _entry_header_html(ctx, oob=True)),
entry_admin_oob_wrap=SxExpr(await oob_header_sx("entry-header-child",
"entry-admin-header-child", await _entry_admin_header_html(ctx))),
clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
"post-admin-row", "post-admin-header-child",
"calendar-row", "calendar-header-child",
"day-row", "day-header-child",
"entry-row", "entry-header-child",
"entry-admin-row", "entry-admin-header-child")),
)
# --- Ticket types layout (extends entry admin with ticket-types header, + menu) ---
async def _ticket_types_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-ticket-types-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
day_header=SxExpr(await _day_header_sx(ctx)),
entry_header=SxExpr(await _entry_header_html(ctx)),
entry_admin_header=SxExpr(await _entry_admin_header_html(ctx)),
ticket_types_header=SxExpr(await _ticket_types_header_html(ctx)),
)
async def _ticket_types_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, oob_header_sx
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-ticket-types-layout-oob", _ctx_to_env(ctx, oob=True),
entry_admin_oob=SxExpr(await _entry_admin_header_html(ctx, oob=True)),
ticket_types_oob_wrap=SxExpr(await oob_header_sx("entry-admin-header-child",
"ticket_types-header-child", await _ticket_types_header_html(ctx))),
)
# --- Ticket type detail layout (extends ticket types with ticket-type header, + menu) ---
async def _ticket_type_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-ticket-type-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
calendar_header=SxExpr(await _calendar_header_sx(ctx)),
day_header=SxExpr(await _day_header_sx(ctx)),
entry_header=SxExpr(await _entry_header_html(ctx)),
entry_admin_header=SxExpr(await _entry_admin_header_html(ctx)),
ticket_types_header=SxExpr(await _ticket_types_header_html(ctx)),
ticket_type_header=SxExpr(await _ticket_type_header_html(ctx)),
)
async def _ticket_type_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, oob_header_sx
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-ticket-type-layout-oob", _ctx_to_env(ctx, oob=True),
ticket_types_oob=SxExpr(await _ticket_types_header_html(ctx, oob=True)),
ticket_type_oob_wrap=SxExpr(await oob_header_sx("ticket_types-header-child",
"ticket_type-header-child", await _ticket_type_header_html(ctx))),
)
# --- Markets layout (root + child(post + markets)) ---
async def _markets_full(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-markets-layout-full", _ctx_to_env(ctx),
post_header=SxExpr(await _post_header_sx(ctx)),
markets_header=SxExpr(await _markets_header_sx(ctx)),
)
async def _markets_oob(ctx: dict, **kw: Any) -> str:
from shared.sx.helpers import render_to_sx_with_env, _ctx_to_env, oob_header_sx
from shared.sx.parser import SxExpr
return await render_to_sx_with_env("events-markets-layout-oob", _ctx_to_env(ctx, oob=True),
post_oob=SxExpr(await _post_header_sx(ctx, oob=True)),
markets_oob_wrap=SxExpr(await oob_header_sx("post-header-child",
"markets-header-child", await _markets_header_sx(ctx))),
)
# ---------------------------------------------------------------------------
# Page helpers
# ---------------------------------------------------------------------------
@@ -209,7 +509,6 @@ def _register_events_helpers() -> None:
async def _h_calendar_admin_content(calendar_slug=None, **kw):
await _ensure_calendar(calendar_slug)
from shared.sx.page import get_template_context
from .calendar import _calendar_admin_main_panel_html
ctx = await get_template_context()
return await _calendar_admin_main_panel_html(ctx)
@@ -218,7 +517,6 @@ async def _h_day_admin_content(calendar_slug=None, year=None, month=None, day=No
await _ensure_calendar(calendar_slug)
if year is not None:
await _ensure_day_data(int(year), int(month), int(day))
from .calendar import _day_admin_main_panel_html
return await _day_admin_main_panel_html({})
@@ -227,7 +525,6 @@ async def _h_slots_content(calendar_slug=None, **kw):
await _ensure_calendar(calendar_slug)
calendar = getattr(g, "calendar", None)
from bp.slots.services.slots import list_slots as svc_list_slots
from .slots import render_slots_table
slots = await svc_list_slots(g.s, calendar.id) if calendar else []
_add_to_defpage_ctx(slots=slots)
return await render_slots_table(slots, calendar)
@@ -237,7 +534,6 @@ async def _h_slot_content(calendar_slug=None, slot_id=None, **kw):
from quart import g, abort
await _ensure_calendar(calendar_slug)
from bp.slot.services.slot import get_slot as svc_get_slot
from .slots import render_slot_main_panel
slot = await svc_get_slot(g.s, slot_id) if slot_id else None
if not slot:
abort(404)
@@ -251,7 +547,6 @@ async def _h_entry_content(calendar_slug=None, entry_id=None, **kw):
await _ensure_calendar(calendar_slug)
await _ensure_entry_context(entry_id)
from shared.sx.page import get_template_context
from .entries import _entry_main_panel_html
ctx = await get_template_context()
return await _entry_main_panel_html(ctx)
@@ -260,7 +555,6 @@ async def _h_entry_menu(calendar_slug=None, entry_id=None, **kw):
await _ensure_calendar(calendar_slug)
await _ensure_entry_context(entry_id)
from shared.sx.page import get_template_context
from .entries import _entry_nav_html
ctx = await get_template_context()
return await _entry_nav_html(ctx)
@@ -269,7 +563,6 @@ async def _h_entry_admin_content(calendar_slug=None, entry_id=None, **kw):
await _ensure_calendar(calendar_slug)
await _ensure_entry_context(entry_id)
from shared.sx.page import get_template_context
from .entries import _entry_admin_main_panel_html
ctx = await get_template_context()
return await _entry_admin_main_panel_html(ctx)
@@ -287,7 +580,6 @@ async def _h_ticket_types_content(calendar_slug=None, entry_id=None,
entry = getattr(g, "entry", None)
calendar = getattr(g, "calendar", None)
from bp.ticket_types.services.tickets import list_ticket_types as svc_list_ticket_types
from .tickets import render_ticket_types_table
ticket_types = await svc_list_ticket_types(g.s, entry.id) if entry else []
_add_to_defpage_ctx(ticket_types=ticket_types)
return await render_ticket_types_table(ticket_types, entry, calendar, day, month, year)
@@ -299,7 +591,6 @@ async def _h_ticket_type_content(calendar_slug=None, entry_id=None,
await _ensure_calendar(calendar_slug)
await _ensure_entry(entry_id)
from bp.ticket_type.services.ticket import get_ticket_type as svc_get_ticket_type
from .tickets import render_ticket_type_main_panel
ticket_type = await svc_get_ticket_type(g.s, ticket_type_id) if ticket_type_id else None
if not ticket_type:
abort(404)
@@ -314,7 +605,6 @@ async def _h_tickets_content(**kw):
from quart import g
from shared.infrastructure.cart_identity import current_cart_identity
from bp.tickets.services.tickets import get_user_tickets
from .tickets import _tickets_main_panel_html
ident = current_cart_identity()
tickets = await get_user_tickets(
g.s,
@@ -330,7 +620,6 @@ async def _h_ticket_detail_content(code=None, **kw):
from quart import g, abort
from shared.infrastructure.cart_identity import current_cart_identity
from bp.tickets.services.tickets import get_ticket_by_code
from .tickets import _ticket_detail_panel_html
ticket = await get_ticket_by_code(g.s, code) if code else None
if not ticket:
abort(404)
@@ -354,7 +643,6 @@ async def _h_ticket_admin_content(**kw):
from sqlalchemy import select, func
from sqlalchemy.orm import selectinload
from models.calendars import CalendarEntry, Ticket
from .tickets import _ticket_admin_main_panel_html
result = await g.s.execute(
select(Ticket)
@@ -391,6 +679,5 @@ async def _h_ticket_admin_content(**kw):
async def _h_markets_content(**kw):
from shared.sx.page import get_template_context
from .calendar import _markets_main_panel_html
ctx = await get_template_context()
return await _markets_main_panel_html(ctx)