diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml
index 4d38535..1eec7f5 100644
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@@ -84,13 +84,25 @@ jobs:
fi
done
- # Deploy swarm stack only on main branch
+ # Deploy swarm stacks only on main branch
if [ '${{ github.ref_name }}' = 'main' ]; then
source .env
docker stack deploy -c docker-compose.yml rose-ash
echo 'Waiting for swarm services to update...'
sleep 10
docker stack services rose-ash
+
+ # Deploy sx-web standalone stack (sx-web.org)
+ SX_REBUILT=false
+ if [ \"\$REBUILD_ALL\" = true ] || echo \"\$CHANGED\" | grep -q '^sx/'; then
+ SX_REBUILT=true
+ fi
+ if [ \"\$SX_REBUILT\" = true ]; then
+ echo 'Deploying sx-web stack (sx-web.org)...'
+ docker stack deploy -c /root/sx-web/docker-compose.yml sx-web
+ sleep 5
+ docker stack services sx-web
+ fi
else
echo 'Skipping swarm deploy (branch: ${{ github.ref_name }})'
fi
diff --git a/CLAUDE.md b/CLAUDE.md
index 7fb92ec..297672f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -52,6 +52,65 @@ artdag/
test/ # Integration & e2e tests
```
+## SX Language — Canonical Reference
+
+The SX language is defined by a self-hosting specification in `shared/sx/ref/`. **Read these files for authoritative SX semantics** — they supersede any implementation detail in `sx.js` or Python evaluators.
+
+### Specification files
+
+- **`shared/sx/ref/eval.sx`** — Core evaluator: types, trampoline (TCO), `eval-expr` dispatch, special forms (`if`, `when`, `cond`, `case`, `let`, `and`, `or`, `lambda`, `define`, `defcomp`, `defmacro`, `quasiquote`), higher-order forms (`map`, `filter`, `reduce`, `some`, `every?`, `for-each`), macro expansion, function/lambda/component calling.
+- **`shared/sx/ref/parser.sx`** — Tokenizer and parser: grammar, string escapes, dict literals `{:key val}`, quote sugar (`` ` ``, `,`, `,@`), serializer.
+- **`shared/sx/ref/primitives.sx`** — All ~80 built-in pure functions: arithmetic, comparison, predicates, string ops, collection ops, dict ops, format helpers, CSSX style primitives.
+- **`shared/sx/ref/render.sx`** — Three rendering modes: `render-to-html` (server HTML), `render-to-sx`/`aser` (SX wire format for client), `render-to-dom` (browser). HTML tag registry, void elements, boolean attrs.
+- **`shared/sx/ref/bootstrap_js.py`** — Transpiler: reads the `.sx` spec files and emits `sx-ref.js`.
+
+### Type system
+
+```
+number, string, boolean, nil, symbol, keyword, list, dict,
+lambda, component, macro, thunk (TCO deferred eval)
+```
+
+### Evaluation rules (from eval.sx)
+
+1. **Literals** (number, string, boolean, nil) — pass through
+2. **Symbols** — look up in env, then primitives, then `true`/`false`/`nil`, else error
+3. **Keywords** — evaluate to their string name
+4. **Dicts** — evaluate all values recursively
+5. **Lists** — dispatch on head:
+ - Special forms (`if`, `when`, `cond`, `case`, `let`, `lambda`, `define`, `defcomp`, `defmacro`, `quote`, `quasiquote`, `begin`/`do`, `set!`, `->`)
+ - Higher-order forms (`map`, `filter`, `reduce`, `some`, `every?`, `for-each`, `map-indexed`)
+ - Macros — expand then re-evaluate
+ - Function calls — evaluate head and args, then: native callable → `apply`, lambda → bind params + TCO thunk, component → parse keyword args + bind params + TCO thunk
+
+### Component calling convention
+
+```lisp
+(defcomp ~card (&key title subtitle &rest children)
+ (div :class "card"
+ (h2 title)
+ (when subtitle (p subtitle))
+ children))
+```
+
+- `&key` params are keyword arguments: `(~card :title "Hi" :subtitle "Sub")`
+- `&rest children` captures positional args as `children`
+- Component body evaluated in merged env: `closure + caller-env + bound-params`
+
+### Rendering modes (from render.sx)
+
+| Mode | Function | Expands components? | Output |
+|------|----------|-------------------|--------|
+| HTML | `render-to-html` | Yes (recursive) | HTML string |
+| SX wire | `aser` | No — serializes `(~name ...)` | SX source text |
+| DOM | `render-to-dom` | Yes (recursive) | DOM nodes |
+
+The `aser` (async-serialize) mode evaluates control flow and function calls but serializes HTML tags and component calls as SX source — the client renders them. This is the wire format for HTMX-like responses.
+
+### Platform interface
+
+Each target (JS, Python) must provide: type inspection (`type-of`), constructors (`make-lambda`, `make-component`, `make-macro`, `make-thunk`), accessors, environment operations (`env-has?`, `env-get`, `env-set!`, `env-extend`, `env-merge`), and DOM/HTML rendering primitives.
+
## Tech Stack
**Web platform:** Python 3.11+, Quart (async Flask), SQLAlchemy (asyncpg), Jinja2, HTMX, PostgreSQL, Redis, Docker Swarm, Hypercorn.
@@ -110,11 +169,11 @@ cd artdag/l1 && mypy app/types.py app/routers/recipes.py tests/
### SX Rendering Pipeline
-The SX system renders component trees defined in s-expressions. The same AST can be evaluated in different modes depending on where the server/client rendering boundary is drawn:
+The SX system renders component trees defined in s-expressions. Canonical semantics are in `shared/sx/ref/` (see "SX Language" section above). The same AST can be evaluated in different modes depending on where the server/client rendering boundary is drawn:
-- `render_to_html(name, **kw)` — server-side, produces HTML. Used by route handlers returning full HTML.
-- `render_to_sx(name, **kw)` — server-side, produces SX wire format. Component calls stay **unexpanded** (serialized for client-side rendering by sx.js).
-- `render_to_sx_with_env(name, env, **kw)` — server-side, **expands the top-level component** then serializes children as SX wire format. Used by layout components that need Python context (auth state, fragments, URLs) resolved server-side.
+- `render_to_html(name, **kw)` — server-side, produces HTML. Maps to `render-to-html` in the spec.
+- `render_to_sx(name, **kw)` — server-side, produces SX wire format. Maps to `aser` in the spec. Component calls stay **unexpanded**.
+- `render_to_sx_with_env(name, env, **kw)` — server-side, **expands known components** then serializes as SX wire format. Used by layout components that need Python context.
- `sx_page(ctx, page_sx)` — produces the full HTML shell (`...`) with component definitions, CSS, and page SX inlined for client-side boot.
See the docstring in `shared/sx/async_eval.py` for the full evaluation modes table.
diff --git a/account/bp/account/routes.py b/account/bp/account/routes.py
index 9129c3c..f300d9e 100644
--- a/account/bp/account/routes.py
+++ b/account/bp/account/routes.py
@@ -69,7 +69,7 @@ def register(url_prefix="/"):
return sx_response(sx_call(
"account-newsletter-toggle",
id=f"nl-{nid}", url=toggle_url,
- hdrs=f'{{"X-CSRFToken": "{csrf}"}}',
+ hdrs={"X-CSRFToken": csrf},
target=f"#nl-{nid}",
cls=f"relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 {bg}",
checked=checked,
diff --git a/account/sx/newsletters.sx b/account/sx/newsletters.sx
index 4b0626b..b051d2a 100644
--- a/account/sx/newsletters.sx
+++ b/account/sx/newsletters.sx
@@ -54,7 +54,7 @@
:toggle (~account-newsletter-toggle
:id (str "nl-" nid)
:url toggle-url
- :hdrs (str "{\"X-CSRFToken\": \"" csrf "\"}")
+ :hdrs {:X-CSRFToken csrf}
:target (str "#nl-" nid)
:cls (str "relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 " bg)
:checked checked
diff --git a/blog/bp/post/admin/routes.py b/blog/bp/post/admin/routes.py
index 5ae0db0..4cbaf70 100644
--- a/blog/bp/post/admin/routes.py
+++ b/blog/bp/post/admin/routes.py
@@ -10,11 +10,18 @@ from quart import (
url_for,
)
from shared.browser.app.authz import require_admin, require_post_author
+from markupsafe import escape
from shared.sx.helpers import sx_response, sx_call
from shared.sx.parser import SxExpr, serialize as sx_serialize
from shared.utils import host_url
+def _raw_html_sx(html: str) -> str:
+ """Wrap raw HTML in (raw! "...") so it's valid inside sx source."""
+ if not html:
+ return ""
+ return "(raw! " + sx_serialize(html) + ")"
+
def _post_to_edit_dict(post) -> dict:
"""Convert an ORM Post to a dict matching the shape templates expect.
@@ -89,58 +96,95 @@ def _render_calendar_view(
prev_year, next_year, month_entries, associated_entry_ids,
post_slug: str,
) -> str:
- """Build calendar month grid via ~blog-calendar-view defcomp."""
+ """Build calendar month grid HTML."""
from quart import url_for as qurl
from shared.browser.app.csrf import generate_csrf_token
+ esc = escape
- cal_id = calendar.id
csrf = generate_csrf_token()
+ cal_id = calendar.id
def cal_url(y, m):
- return host_url(qurl("blog.post.admin.calendar_view",
- slug=post_slug, calendar_id=cal_id, year=y, month=m))
+ return esc(host_url(qurl("blog.post.admin.calendar_view", slug=post_slug, calendar_id=cal_id, year=y, month=m)))
- # Flatten weeks into day dicts with pre-computed entries per day
- days = []
+ cur_url = cal_url(year, month)
+ toggle_url_fn = lambda eid: esc(host_url(qurl("blog.post.admin.toggle_entry", slug=post_slug, entry_id=eid)))
+
+ nav = (
+ f''
+ f''
+ )
+
+ wd_cells = "".join(f'{esc(wd)}
' for wd in weekday_names)
+ wd_row = f'{wd_cells}
'
+
+ cells: list[str] = []
for week in weeks:
for day in week:
+ extra_cls = " bg-stone-50 text-stone-400" if not day.in_month else ""
day_date = day.date
- day_entries = []
+
+ entry_btns: list[str] = []
for e in month_entries:
e_start = getattr(e, "start_at", None)
if not e_start or e_start.date() != day_date:
continue
e_id = getattr(e, "id", None)
- toggle_url = host_url(qurl("blog.post.admin.toggle_entry",
- slug=post_slug, entry_id=e_id))
- day_entries.append({
- "name": str(getattr(e, "name", "")),
- "toggle_url": toggle_url,
- "is_associated": e_id in associated_entry_ids,
- })
- # Wrap nested entries list as SxExpr so it serializes as (list ...)
- entries_sx = SxExpr("(list " + " ".join(
- sx_serialize(e) for e in day_entries
- ) + ")") if day_entries else None
- days.append({
- "day": day_date.day,
- "in_month": day.in_month,
- "entries": entries_sx,
- })
+ e_name = esc(getattr(e, "name", ""))
+ t_url = toggle_url_fn(e_id)
+ hx_hdrs = '{:X-CSRFToken "' + csrf + '"}'
- return sx_call("blog-calendar-view",
- cal_id=str(cal_id),
- year=str(year),
- month_name=month_name,
- current_url=cal_url(year, month),
- prev_month_url=cal_url(prev_month_year, prev_month),
- prev_year_url=cal_url(prev_year, month),
- next_month_url=cal_url(next_month_year, next_month),
- next_year_url=cal_url(next_year, month),
- weekday_names=list(weekday_names),
- days=days,
- csrf=csrf,
+ if e_id in associated_entry_ids:
+ entry_btns.append(
+ f''
+ f'{e_name}'
+ f'
'
+ )
+ else:
+ entry_btns.append(
+ f''
+ )
+
+ entries_html = '' + "".join(entry_btns) + '
' if entry_btns else ''
+ cells.append(
+ f''
+ )
+
+ grid = f'{"".join(cells)}
'
+
+ html = (
+ f''
+ f'{nav}'
+ f'
{wd_row}{grid}
'
+ f'
/"
:auth :public
:layout :root
- :content (ticket-detail-content code))
+ :data (ticket-detail-data code)
+ :content (~events-ticket-detail
+ :list-container list-container :back-href back-href
+ :header-bg header-bg :entry-name entry-name
+ :badge (span :class (str "inline-flex items-center rounded-full px-3 py-1 text-sm font-medium " badge-cls)
+ badge-label)
+ :type-name type-name :code ticket-code
+ :time-date time-date :time-range time-range
+ :cal-name cal-name :type-desc type-desc :checkin-str checkin-str
+ :qr-script qr-script))
;; Ticket admin dashboard
(defpage ticket-admin
:path "/admin/tickets/"
:auth :admin
:layout :root
- :content (ticket-admin-content))
+ :data (ticket-admin-data)
+ :content (~events-ticket-admin-panel
+ :list-container list-container
+ :stats (<> (map (fn (s)
+ (~events-ticket-admin-stat
+ :border (get s "border") :bg (get s "bg")
+ :text-cls (get s "text-cls") :label-cls (get s "label-cls")
+ :value (get s "value") :label (get s "label")))
+ admin-stats))
+ :lookup-url lookup-url :has-tickets has-tickets
+ :rows (when has-tickets
+ (<> (map (fn (t)
+ (~events-ticket-admin-row
+ :code (get t "code") :code-short (get t "code-short")
+ :entry-name (get t "entry-name")
+ :date (when (get t "date-str")
+ (~events-ticket-admin-date :date-str (get t "date-str")))
+ :type-name (get t "type-name")
+ :badge (~badge :cls (get t "badge-cls") :label (get t "badge-label"))
+ :action (if (get t "can-checkin")
+ (~events-ticket-admin-checkin-form
+ :checkin-url (get t "checkin-url") :code (get t "code") :csrf csrf)
+ (when (get t "is-checked-in")
+ (~events-ticket-admin-checked-in :time-str (get t "checkin-time"))))))
+ admin-tickets)))))
;; Markets
(defpage events-markets
:path "//markets/"
:auth :public
:layout :events-markets
- :content (markets-content))
+ :data (markets-data)
+ :content (~crud-panel
+ :list-id "markets-list"
+ :form (when can-create
+ (~crud-create-form :create-url create-url :csrf csrf
+ :errors-id "market-create-errors" :list-id "markets-list"
+ :placeholder "e.g. Farm Shop, Bakery" :btn-label "Add market"))
+ :list (if markets-list
+ (<> (map (fn (m)
+ (~crud-item :href (get m "href") :name (get m "name")
+ :slug (get m "slug") :del-url (get m "del-url")
+ :csrf-hdr (get m "csrf-hdr")
+ :list-id "markets-list"
+ :confirm-title "Delete market?"
+ :confirm-text "Products will be hidden (soft delete)"))
+ markets-list))
+ (~empty-state :message "No markets yet. Create one above."
+ :cls "text-gray-500 mt-4"))))
diff --git a/events/sxc/pages/helpers.py b/events/sxc/pages/helpers.py
index 2925ca8..b005fbb 100644
--- a/events/sxc/pages/helpers.py
+++ b/events/sxc/pages/helpers.py
@@ -1,26 +1,13 @@
-"""Layout registrations, page helpers, and shared hydration helpers."""
+"""Layout registrations, page helpers, and shared hydration helpers.
+
+All helpers return data dicts — no sx_call().
+Markup composition lives entirely in .sx defpage and .sx defcomp files.
+"""
from __future__ import annotations
from typing import Any
-from shared.sx.helpers import sx_call
-
-from .calendar import (
- _calendar_admin_main_panel_html,
- _day_admin_main_panel_html,
- _markets_main_panel_html,
-)
-from .entries import (
- _entry_main_panel_html,
- _entry_nav_html,
- _entry_admin_main_panel_html,
-)
-from .tickets import (
- _tickets_main_panel_html, _ticket_detail_panel_html,
- _ticket_admin_main_panel_html,
- render_ticket_type_main_panel, render_ticket_types_table,
-)
-from .slots import render_slot_main_panel, render_slots_table
+from shared.sx.parser import SxExpr
# ---------------------------------------------------------------------------
@@ -261,6 +248,60 @@ def _register_events_layouts() -> None:
"events-markets-layout-full", "events-markets-layout-oob")
+# ---------------------------------------------------------------------------
+# Badge data helpers
+# ---------------------------------------------------------------------------
+
+_ENTRY_STATE_CLASSES = {
+ "confirmed": "bg-emerald-100 text-emerald-800",
+ "provisional": "bg-amber-100 text-amber-800",
+ "ordered": "bg-sky-100 text-sky-800",
+ "pending": "bg-stone-100 text-stone-700",
+ "declined": "bg-red-100 text-red-800",
+}
+
+_TICKET_STATE_CLASSES = {
+ "confirmed": "bg-emerald-100 text-emerald-800",
+ "checked_in": "bg-blue-100 text-blue-800",
+ "reserved": "bg-amber-100 text-amber-800",
+ "cancelled": "bg-red-100 text-red-800",
+}
+
+
+def _entry_badge_data(state: str) -> dict:
+ cls = _ENTRY_STATE_CLASSES.get(state, "bg-stone-100 text-stone-700")
+ label = state.replace("_", " ").capitalize()
+ return {"cls": cls, "label": label}
+
+
+def _ticket_badge_data(state: str) -> dict:
+ cls = _TICKET_STATE_CLASSES.get(state, "bg-stone-100 text-stone-700")
+ label = (state or "").replace("_", " ").capitalize()
+ return {"cls": cls, "label": label}
+
+
+# ---------------------------------------------------------------------------
+# Styles helper
+# ---------------------------------------------------------------------------
+
+def _styles_data() -> dict:
+ """Extract common style classes from g.styles."""
+ from quart import g
+ styles = getattr(g, "styles", None) or {}
+
+ def _gs(attr):
+ return getattr(styles, attr, "") if hasattr(styles, attr) else styles.get(attr, "")
+
+ return {
+ "list-container": _gs("list_container"),
+ "pre-action": _gs("pre_action_button"),
+ "action-btn": _gs("action_button"),
+ "tr-cls": _gs("tr"),
+ "pill-cls": _gs("pill"),
+ "nav-btn": _gs("nav_button"),
+ }
+
+
# ---------------------------------------------------------------------------
# Page helpers
# ---------------------------------------------------------------------------
@@ -269,141 +310,468 @@ def _register_events_helpers() -> None:
from shared.sx.pages import register_page_helpers
register_page_helpers("events", {
- "calendar-admin-content": _h_calendar_admin_content,
- "day-admin-content": _h_day_admin_content,
- "slots-content": _h_slots_content,
- "slot-content": _h_slot_content,
- "entry-content": _h_entry_content,
- "entry-menu": _h_entry_menu,
- "entry-admin-content": _h_entry_admin_content,
- "admin-menu": _h_admin_menu,
- "ticket-types-content": _h_ticket_types_content,
- "ticket-type-content": _h_ticket_type_content,
- "tickets-content": _h_tickets_content,
- "ticket-detail-content": _h_ticket_detail_content,
- "ticket-admin-content": _h_ticket_admin_content,
- "markets-content": _h_markets_content,
+ "calendar-admin-data": _h_calendar_admin_data,
+ "day-admin-data": _h_day_admin_data,
+ "slots-data": _h_slots_data,
+ "slot-data": _h_slot_data,
+ "entry-data": _h_entry_data,
+ "entry-admin-data": _h_entry_admin_data,
+ "ticket-types-data": _h_ticket_types_data,
+ "ticket-type-data": _h_ticket_type_data,
+ "tickets-data": _h_tickets_data,
+ "ticket-detail-data": _h_ticket_detail_data,
+ "ticket-admin-data": _h_ticket_admin_data,
+ "markets-data": _h_markets_data,
})
-async def _h_calendar_admin_content(calendar_slug=None, **kw):
+# ---------------------------------------------------------------------------
+# Calendar admin
+# ---------------------------------------------------------------------------
+
+async def _h_calendar_admin_data(calendar_slug=None, **kw) -> dict:
+ from quart import url_for
+ from shared.browser.app.csrf import generate_csrf_token
+
await _ensure_calendar(calendar_slug)
await _ensure_container_nav_defpage_ctx()
- from shared.sx.page import get_template_context
- ctx = await get_template_context()
- return _calendar_admin_main_panel_html(ctx)
+
+ from quart import g
+ calendar = getattr(g, "calendar", None)
+ if not calendar:
+ return {}
+
+ csrf = generate_csrf_token()
+ cal_slug = getattr(calendar, "slug", "")
+ desc = getattr(calendar, "description", "") or ""
+ desc_edit_url = url_for("calendar.admin.calendar_description_edit",
+ calendar_slug=cal_slug)
+
+ return {
+ "cal-description": desc,
+ "csrf": csrf,
+ "desc-edit-url": desc_edit_url,
+ }
-async def _h_day_admin_content(calendar_slug=None, year=None, month=None, day=None, **kw):
+# ---------------------------------------------------------------------------
+# Day admin
+# ---------------------------------------------------------------------------
+
+async def _h_day_admin_data(calendar_slug=None, year=None, month=None,
+ day=None, **kw) -> dict:
await _ensure_calendar(calendar_slug)
await _ensure_container_nav_defpage_ctx()
if year is not None:
await _ensure_day_data(int(year), int(month), int(day))
- return _day_admin_main_panel_html({})
+ return {}
-async def _h_slots_content(calendar_slug=None, **kw):
- from quart import g
+# ---------------------------------------------------------------------------
+# Slots listing
+# ---------------------------------------------------------------------------
+
+async def _h_slots_data(calendar_slug=None, **kw) -> dict:
+ from quart import g, url_for
+ from shared.browser.app.csrf import generate_csrf_token
+ from bp.slots.services.slots import list_slots as svc_list_slots
+
await _ensure_calendar(calendar_slug)
await _ensure_container_nav_defpage_ctx()
+
calendar = getattr(g, "calendar", None)
- from bp.slots.services.slots import list_slots as svc_list_slots
slots = await svc_list_slots(g.s, calendar.id) if calendar else []
_add_to_defpage_ctx(slots=slots)
- return render_slots_table(slots, calendar)
+
+ styles = _styles_data()
+ csrf = generate_csrf_token()
+ cal_slug = getattr(calendar, "slug", "")
+ hx_select = getattr(g, "hx_select_search", "#main-panel")
+ csrf_hdr = {"X-CSRFToken": csrf}
+ add_url = url_for("calendar.slots.add_form", calendar_slug=cal_slug)
+
+ slots_list = []
+ for s in slots:
+ slot_href = url_for("defpage_slot_detail",
+ calendar_slug=cal_slug, slot_id=s.id)
+ del_url = url_for("calendar.slots.slot.slot_delete",
+ calendar_slug=cal_slug, slot_id=s.id)
+ desc = getattr(s, "description", "") or ""
+ days_display = getattr(s, "days_display", "\u2014")
+ day_list = days_display.split(", ")
+ has_days = bool(day_list and day_list[0] != "\u2014")
+ time_start = s.time_start.strftime("%H:%M") if s.time_start else ""
+ time_end = s.time_end.strftime("%H:%M") if s.time_end else ""
+ cost = getattr(s, "cost", None)
+ cost_str = f"{cost:.2f}" if cost is not None else ""
+
+ slots_list.append({
+ "name": s.name,
+ "description": desc,
+ "day-list": day_list if has_days else [],
+ "has-days": has_days,
+ "flexible": "yes" if s.flexible else "no",
+ "time-str": f"{time_start} - {time_end}",
+ "cost-str": cost_str,
+ "slot-href": slot_href,
+ "del-url": del_url,
+ })
+
+ return {
+ "has-slots": bool(slots),
+ "slots-list": slots_list,
+ "add-url": add_url,
+ "csrf-hdr": csrf_hdr,
+ "hx-select": hx_select,
+ **styles,
+ }
-async def _h_slot_content(calendar_slug=None, slot_id=None, **kw):
- from quart import g, abort
+# ---------------------------------------------------------------------------
+# Slot detail
+# ---------------------------------------------------------------------------
+
+async def _h_slot_data(calendar_slug=None, slot_id=None, **kw) -> dict:
+ from quart import g, abort, url_for
+
await _ensure_calendar(calendar_slug)
await _ensure_container_nav_defpage_ctx()
+
from bp.slot.services.slot import get_slot as svc_get_slot
slot = await svc_get_slot(g.s, slot_id) if slot_id else None
if not slot:
abort(404)
g.slot = slot
_add_to_defpage_ctx(slot=slot)
+
calendar = getattr(g, "calendar", None)
- return render_slot_main_panel(slot, calendar)
+ styles = _styles_data()
+ cal_slug = getattr(calendar, "slug", "")
+
+ days_display = getattr(slot, "days_display", "\u2014")
+ day_list = days_display.split(", ")
+ has_days = bool(day_list and day_list[0] != "\u2014")
+ time_start = slot.time_start.strftime("%H:%M") if slot.time_start else ""
+ time_end = slot.time_end.strftime("%H:%M") if slot.time_end else ""
+ cost = getattr(slot, "cost", None)
+ cost_str = f"{cost:.2f}" if cost is not None else ""
+ edit_url = url_for("calendar.slots.slot.get_edit",
+ slot_id=slot.id, calendar_slug=cal_slug)
+
+ return {
+ "slot-id-str": str(slot.id),
+ "day-list": day_list if has_days else [],
+ "has-days": has_days,
+ "flexible": "yes" if getattr(slot, "flexible", False) else "no",
+ "time-str": f"{time_start} \u2014 {time_end}",
+ "cost-str": cost_str,
+ "edit-url": edit_url,
+ **styles,
+ }
-async def _h_entry_content(calendar_slug=None, entry_id=None, **kw):
+# ---------------------------------------------------------------------------
+# Entry detail (complex — sub-panels returned as SxExpr)
+# ---------------------------------------------------------------------------
+
+async def _h_entry_data(calendar_slug=None, entry_id=None, **kw) -> dict:
+ from quart import url_for, g
+ from .entries import (
+ _entry_nav_html,
+ _entry_options_html,
+ render_entry_tickets_config,
+ render_entry_posts_panel,
+ )
+ from .tickets import render_buy_form
+
await _ensure_calendar(calendar_slug)
await _ensure_entry_context(entry_id)
+
from shared.sx.page import get_template_context
ctx = await get_template_context()
- return _entry_main_panel_html(ctx)
+
+ entry = ctx.get("entry")
+ if not entry:
+ return {}
+
+ calendar = ctx.get("calendar")
+ cal_slug = getattr(calendar, "slug", "") if calendar else ""
+ day = ctx.get("day")
+ month = ctx.get("month")
+ year = ctx.get("year")
+
+ styles = _styles_data()
+ eid = entry.id
+ state = getattr(entry, "state", "pending") or "pending"
+
+ # Simple field data
+ slot = getattr(entry, "slot", None)
+ has_slot = slot is not None
+ slot_name = slot.name if slot else ""
+ flex_label = "(flexible)" if slot and getattr(slot, "flexible", False) else "(fixed)"
+ start_str = entry.start_at.strftime("%H:%M") if entry.start_at else ""
+ end_str = f" \u2013 {entry.end_at.strftime('%H:%M')}" if entry.end_at else " \u2013 open-ended"
+ cost = getattr(entry, "cost", None)
+ cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+ date_str = entry.start_at.strftime("%A, %B %d, %Y") if entry.start_at else ""
+ badge = _entry_badge_data(state)
+
+ edit_url = url_for(
+ "calendar.day.calendar_entries.calendar_entry.get_edit",
+ entry_id=eid, calendar_slug=cal_slug,
+ day=day, month=month, year=year,
+ )
+
+ # Complex sub-panels (pre-composed as SxExpr)
+ ticket_remaining = ctx.get("ticket_remaining")
+ ticket_sold_count = ctx.get("ticket_sold_count", 0)
+ user_ticket_count = ctx.get("user_ticket_count", 0)
+ user_ticket_counts_by_type = ctx.get("user_ticket_counts_by_type") or {}
+ entry_posts = ctx.get("entry_posts") or []
+
+ tickets_config = render_entry_tickets_config(entry, calendar, day, month, year)
+ buy_form = render_buy_form(
+ entry, ticket_remaining, ticket_sold_count,
+ user_ticket_count, user_ticket_counts_by_type,
+ )
+ posts_panel = render_entry_posts_panel(
+ entry_posts, entry, calendar, day, month, year,
+ )
+ options_html = _entry_options_html(entry, calendar, day, month, year)
+
+ # Entry menu (pre-composed for :menu slot)
+ entry_menu = _entry_nav_html(ctx)
+
+ return {
+ "entry-id-str": str(eid),
+ "entry-name": entry.name,
+ "has-slot": has_slot,
+ "slot-name": slot_name,
+ "flex-label": flex_label,
+ "time-str": start_str + end_str,
+ "state-badge-cls": badge["cls"],
+ "state-badge-label": badge["label"],
+ "cost-str": cost_str,
+ "date-str": date_str,
+ "edit-url": edit_url,
+ "tickets-config": SxExpr(tickets_config),
+ "buy-form": SxExpr(buy_form) if buy_form else None,
+ "posts-panel": SxExpr(posts_panel),
+ "options-html": SxExpr(options_html),
+ "entry-menu": SxExpr(entry_menu) if entry_menu else None,
+ **styles,
+ }
-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
- ctx = await get_template_context()
- return _entry_nav_html(ctx)
+# ---------------------------------------------------------------------------
+# Entry admin
+# ---------------------------------------------------------------------------
+async def _h_entry_admin_data(calendar_slug=None, entry_id=None,
+ year=None, month=None, day=None, **kw) -> dict:
+ from quart import url_for, g
-async def _h_entry_admin_content(calendar_slug=None, entry_id=None, **kw):
await _ensure_calendar(calendar_slug)
await _ensure_container_nav_defpage_ctx()
await _ensure_entry_context(entry_id)
+
+ calendar = getattr(g, "calendar", None)
+ entry = getattr(g, "entry", None)
+ if not calendar or not entry:
+ return {}
+
+ cal_slug = getattr(calendar, "slug", "")
+ styles = _styles_data()
+
from shared.sx.page import get_template_context
ctx = await get_template_context()
- return _entry_admin_main_panel_html(ctx)
+ select_colours = ctx.get("select_colours", "")
+
+ ticket_types_href = url_for(
+ "calendar.day.calendar_entries.calendar_entry.ticket_types.get",
+ calendar_slug=cal_slug, entry_id=entry.id,
+ year=year, month=month, day=day,
+ )
+
+ return {
+ "ticket-types-href": ticket_types_href,
+ "select-colours": select_colours,
+ **styles,
+ }
-def _h_admin_menu():
- return sx_call("events-admin-placeholder-nav")
+# ---------------------------------------------------------------------------
+# Ticket types listing
+# ---------------------------------------------------------------------------
+async def _h_ticket_types_data(calendar_slug=None, entry_id=None,
+ year=None, month=None, day=None, **kw) -> dict:
+ from quart import g, url_for
+ from shared.browser.app.csrf import generate_csrf_token
-async def _h_ticket_types_content(calendar_slug=None, entry_id=None,
- year=None, month=None, day=None, **kw):
- from quart import g
await _ensure_calendar(calendar_slug)
await _ensure_entry(entry_id)
+
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
ticket_types = await svc_list_ticket_types(g.s, entry.id) if entry else []
_add_to_defpage_ctx(ticket_types=ticket_types)
- return render_ticket_types_table(ticket_types, entry, calendar, day, month, year)
+
+ styles = _styles_data()
+ csrf = generate_csrf_token()
+ cal_slug = getattr(calendar, "slug", "")
+ hx_select = getattr(g, "hx_select_search", "#main-panel")
+ eid = entry.id if entry else 0
+ csrf_hdr = {"X-CSRFToken": csrf}
+
+ types_list = []
+ for tt in (ticket_types or []):
+ tt_href = url_for(
+ "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get",
+ calendar_slug=cal_slug, year=year, month=month, day=day,
+ entry_id=eid, ticket_type_id=tt.id,
+ )
+ del_url = url_for(
+ "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.delete",
+ calendar_slug=cal_slug, year=year, month=month, day=day,
+ entry_id=eid, ticket_type_id=tt.id,
+ )
+ cost = getattr(tt, "cost", None)
+ cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+
+ types_list.append({
+ "tt-href": tt_href,
+ "tt-name": tt.name,
+ "cost-str": cost_str,
+ "count": str(tt.count),
+ "del-url": del_url,
+ })
+
+ add_url = url_for(
+ "calendar.day.calendar_entries.calendar_entry.ticket_types.add_form",
+ calendar_slug=cal_slug, entry_id=eid, year=year, month=month, day=day,
+ )
+
+ return {
+ "has-types": bool(ticket_types),
+ "types-list": types_list,
+ "add-url": add_url,
+ "csrf-hdr": csrf_hdr,
+ "hx-select": hx_select,
+ **styles,
+ }
-async def _h_ticket_type_content(calendar_slug=None, entry_id=None,
- ticket_type_id=None, year=None, month=None, day=None, **kw):
- from quart import g, abort
+# ---------------------------------------------------------------------------
+# Ticket type detail
+# ---------------------------------------------------------------------------
+
+async def _h_ticket_type_data(calendar_slug=None, entry_id=None,
+ ticket_type_id=None,
+ year=None, month=None, day=None, **kw) -> dict:
+ from quart import g, abort, url_for
+
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
ticket_type = await svc_get_ticket_type(g.s, ticket_type_id) if ticket_type_id else None
if not ticket_type:
abort(404)
g.ticket_type = ticket_type
_add_to_defpage_ctx(ticket_type=ticket_type)
+
entry = getattr(g, "entry", None)
calendar = getattr(g, "calendar", None)
- return render_ticket_type_main_panel(ticket_type, entry, calendar, day, month, year)
+ styles = _styles_data()
+ cal_slug = getattr(calendar, "slug", "")
+ cost = getattr(ticket_type, "cost", None)
+ cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+ count = getattr(ticket_type, "count", 0)
+
+ edit_url = url_for(
+ "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get_edit",
+ ticket_type_id=ticket_type.id, calendar_slug=cal_slug,
+ year=year, month=month, day=day,
+ entry_id=entry.id if entry else 0,
+ )
+
+ return {
+ "ticket-id": str(ticket_type.id),
+ "tt-name": ticket_type.name,
+ "cost-str": cost_str,
+ "count-str": str(count),
+ "edit-url": edit_url,
+ **styles,
+ }
-async def _h_tickets_content(**kw):
- from quart import g
+# ---------------------------------------------------------------------------
+# My tickets
+# ---------------------------------------------------------------------------
+
+async def _h_tickets_data(**kw) -> dict:
+ from quart import g, url_for
from shared.infrastructure.cart_identity import current_cart_identity
from bp.tickets.services.tickets import get_user_tickets
+
ident = current_cart_identity()
tickets = await get_user_tickets(
g.s,
user_id=ident["user_id"],
session_id=ident["session_id"],
)
+
from shared.sx.page import get_template_context
ctx = await get_template_context()
- return _tickets_main_panel_html(ctx, tickets)
+ styles = ctx.get("styles") or {}
+ list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+
+ tickets_list = []
+ for ticket in (tickets or []):
+ href = url_for("defpage_ticket_detail", code=ticket.code)
+ entry = getattr(ticket, "entry", None)
+ entry_name = entry.name if entry else "Unknown event"
+ tt = getattr(ticket, "ticket_type", None)
+ state = getattr(ticket, "state", "")
+ cal = getattr(entry, "calendar", None) if entry else None
+
+ time_str = ""
+ if entry and entry.start_at:
+ time_str = entry.start_at.strftime("%A, %B %d, %Y at %H:%M")
+ if entry.end_at:
+ time_str += f" \u2013 {entry.end_at.strftime('%H:%M')}"
+
+ badge = _ticket_badge_data(state)
+ tickets_list.append({
+ "href": href,
+ "entry-name": entry_name,
+ "type-name": tt.name if tt else None,
+ "time-str": time_str or None,
+ "cal-name": cal.name if cal else None,
+ "badge-cls": badge["cls"],
+ "badge-label": badge["label"],
+ "code-prefix": ticket.code[:8],
+ })
+
+ return {
+ "has-tickets": bool(tickets),
+ "tickets-list": tickets_list,
+ "list-container": list_container,
+ }
-async def _h_ticket_detail_content(code=None, **kw):
- from quart import g, abort
+# ---------------------------------------------------------------------------
+# Ticket detail
+# ---------------------------------------------------------------------------
+
+async def _h_ticket_detail_data(code=None, **kw) -> dict:
+ from quart import g, abort, url_for
from shared.infrastructure.cart_identity import current_cart_identity
from bp.tickets.services.tickets import get_ticket_by_code
+
ticket = await get_ticket_by_code(g.s, code) if code else None
if not ticket:
abort(404)
@@ -417,16 +785,71 @@ async def _h_ticket_detail_content(code=None, **kw):
abort(404)
else:
abort(404)
+
from shared.sx.page import get_template_context
ctx = await get_template_context()
- return _ticket_detail_panel_html(ctx, ticket)
+ styles = ctx.get("styles") or {}
+ list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+
+ entry = getattr(ticket, "entry", None)
+ tt = getattr(ticket, "ticket_type", None)
+ state = getattr(ticket, "state", "")
+ ticket_code = ticket.code
+ cal = getattr(entry, "calendar", None) if entry else None
+ checked_in_at = getattr(ticket, "checked_in_at", None)
+
+ bg_map = {"confirmed": "bg-emerald-50", "checked_in": "bg-blue-50",
+ "reserved": "bg-amber-50"}
+ header_bg = bg_map.get(state, "bg-stone-50")
+ entry_name = entry.name if entry else "Ticket"
+ back_href = url_for("defpage_my_tickets")
+
+ badge = _ticket_badge_data(state)
+
+ time_date = entry.start_at.strftime("%A, %B %d, %Y") if entry and entry.start_at else None
+ time_range = entry.start_at.strftime("%H:%M") if entry and entry.start_at else None
+ if time_range and entry.end_at:
+ time_range += f" \u2013 {entry.end_at.strftime('%H:%M')}"
+
+ tt_desc = f"{tt.name} \u2014 \u00a3{tt.cost:.2f}" if tt and getattr(tt, "cost", None) else None
+ checkin_str = checked_in_at.strftime("Checked in: %B %d, %Y at %H:%M") if checked_in_at else None
+
+ qr_script = (
+ f"(function(){{var c=document.getElementById('ticket-qr-{ticket_code}');"
+ "if(c&&typeof QRCode!=='undefined'){"
+ "var cv=document.createElement('canvas');"
+ f"QRCode.toCanvas(cv,'{ticket_code}',{{width:200,margin:2,color:{{dark:'#1c1917',light:'#ffffff'}}}},function(e){{if(!e)c.appendChild(cv)}});"
+ "}})()"
+ )
+
+ return {
+ "list-container": list_container,
+ "back-href": back_href,
+ "header-bg": header_bg,
+ "entry-name": entry_name,
+ "badge-cls": badge["cls"],
+ "badge-label": badge["label"],
+ "type-name": tt.name if tt else None,
+ "ticket-code": ticket_code,
+ "time-date": time_date,
+ "time-range": time_range,
+ "cal-name": cal.name if cal else None,
+ "type-desc": tt_desc,
+ "checkin-str": checkin_str,
+ "qr-script": qr_script,
+ }
-async def _h_ticket_admin_content(**kw):
- from quart import g
+# ---------------------------------------------------------------------------
+# Ticket admin dashboard
+# ---------------------------------------------------------------------------
+
+async def _h_ticket_admin_data(**kw) -> dict:
+ from quart import g, url_for
from sqlalchemy import select, func
from sqlalchemy.orm import selectinload
from models.calendars import CalendarEntry, Ticket
+ from shared.browser.app.csrf import generate_csrf_token
result = await g.s.execute(
select(Ticket)
@@ -449,20 +872,118 @@ async def _h_ticket_admin_content(**kw):
reserved = await g.s.scalar(
select(func.count(Ticket.id)).where(Ticket.state == "reserved")
)
- stats = {
- "total": total or 0,
- "confirmed": confirmed or 0,
- "checked_in": checked_in or 0,
- "reserved": reserved or 0,
+
+ csrf = generate_csrf_token()
+ lookup_url = url_for("ticket_admin.lookup")
+
+ from shared.sx.page import get_template_context
+ ctx = await get_template_context()
+ styles = ctx.get("styles") or {}
+ list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+
+ # Stats cards data
+ admin_stats = []
+ for label, key, border, bg, text_cls in [
+ ("Total", "total", "border-stone-200", "", "text-stone-900"),
+ ("Confirmed", "confirmed", "border-emerald-200", "bg-emerald-50", "text-emerald-700"),
+ ("Checked In", "checked_in", "border-blue-200", "bg-blue-50", "text-blue-700"),
+ ("Reserved", "reserved", "border-amber-200", "bg-amber-50", "text-amber-700"),
+ ]:
+ val_map = {"total": total, "confirmed": confirmed,
+ "checked_in": checked_in, "reserved": reserved}
+ val = val_map.get(key, 0) or 0
+ lbl_cls = text_cls.replace("700", "600").replace("900", "500") if "stone" not in text_cls else "text-stone-500"
+ admin_stats.append({
+ "border": border, "bg": bg, "text-cls": text_cls,
+ "label-cls": lbl_cls, "value": str(val), "label": label,
+ })
+
+ # Ticket rows data
+ admin_tickets = []
+ for ticket in tickets:
+ entry = getattr(ticket, "entry", None)
+ tt = getattr(ticket, "ticket_type", None)
+ state = getattr(ticket, "state", "")
+ tcode = ticket.code
+ checked_in_at = getattr(ticket, "checked_in_at", None)
+
+ date_str = None
+ if entry and entry.start_at:
+ date_str = entry.start_at.strftime("%d %b %Y, %H:%M")
+
+ badge = _ticket_badge_data(state)
+ can_checkin = state in ("confirmed", "reserved")
+ is_checked_in = state == "checked_in"
+ checkin_url = url_for("ticket_admin.do_checkin", code=tcode) if can_checkin else None
+ checkin_time = checked_in_at.strftime("%H:%M") if checked_in_at else ""
+
+ admin_tickets.append({
+ "code": tcode,
+ "code-short": tcode[:12] + "...",
+ "entry-name": entry.name if entry else "\u2014",
+ "date-str": date_str,
+ "type-name": tt.name if tt else "\u2014",
+ "badge-cls": badge["cls"],
+ "badge-label": badge["label"],
+ "can-checkin": can_checkin,
+ "is-checked-in": is_checked_in,
+ "checkin-url": checkin_url,
+ "checkin-time": checkin_time,
+ })
+
+ return {
+ "admin-stats": admin_stats,
+ "admin-tickets": admin_tickets,
+ "list-container": list_container,
+ "lookup-url": lookup_url,
+ "csrf": csrf,
+ "has-tickets": bool(tickets),
}
- from shared.sx.page import get_template_context
- ctx = await get_template_context()
- return _ticket_admin_main_panel_html(ctx, tickets, stats)
+# ---------------------------------------------------------------------------
+# Markets
+# ---------------------------------------------------------------------------
+
+async def _h_markets_data(**kw) -> dict:
+ from quart import url_for
+ from shared.browser.app.csrf import generate_csrf_token
+ from shared.sx.helpers import call_url
-async def _h_markets_content(**kw):
_ensure_post_defpage_ctx()
+
from shared.sx.page import get_template_context
ctx = await get_template_context()
- return _markets_main_panel_html(ctx)
+
+ rights = ctx.get("rights") or {}
+ is_admin = getattr(rights, "admin", False) if hasattr(rights, "admin") else rights.get("admin", False)
+ has_access = ctx.get("has_access")
+ can_create = has_access("markets.create_market") if callable(has_access) else is_admin
+ csrf = generate_csrf_token()
+ markets_raw = ctx.get("markets") or []
+
+ post = ctx.get("post") or {}
+ slug = post.get("slug", "")
+ csrf_hdr = {"X-CSRFToken": csrf}
+
+ markets_list = []
+ for m in markets_raw:
+ m_slug = getattr(m, "slug", "") if hasattr(m, "slug") else m.get("slug", "")
+ m_name = getattr(m, "name", "") if hasattr(m, "name") else m.get("name", "")
+ market_href = call_url(ctx, "market_url", f"/{slug}/{m_slug}/")
+ del_url = url_for("markets.delete_market", market_slug=m_slug)
+
+ markets_list.append({
+ "href": market_href,
+ "name": m_name,
+ "slug": m_slug,
+ "del-url": del_url,
+ "csrf-hdr": csrf_hdr,
+ })
+
+ return {
+ "can-create": can_create,
+ "create-url": url_for("markets.create_market") if can_create else None,
+ "csrf": csrf,
+ "markets-list": markets_list,
+ }
diff --git a/events/sxc/pages/slots.py b/events/sxc/pages/slots.py
index 4916590..bd95562 100644
--- a/events/sxc/pages/slots.py
+++ b/events/sxc/pages/slots.py
@@ -3,6 +3,7 @@ from __future__ import annotations
from shared.sx.helpers import sx_call
+from shared.sx.parser import SxExpr
# ===========================================================================
@@ -110,9 +111,9 @@ _SLOT_PICKER_JS = """\
# Slot options (shared by entry edit + add forms)
# ---------------------------------------------------------------------------
-def _slot_options_data(day_slots, selected_slot_id=None) -> list:
- """Extract slot option data for sx composition."""
- result = []
+def _slot_options_html(day_slots, selected_slot_id=None) -> str:
+ """Build slot