giles
6c44a5f3d0
Show current subdomain name (blog, cart, events, etc.) next to the site title in the root header row. Remove the redundant second "cart" menu row from cart overview and checkout error pages. Add dev-mode hot-reload for sexp templates: track file mtimes and re-read changed files per-request when RELOAD=true, so .sexp edits are picked up without restarting services. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
842 lines
33 KiB
Python
842 lines
33 KiB
Python
"""
|
|
Cart service s-expression page components.
|
|
|
|
Renders cart overview, page cart, orders list, and single order detail.
|
|
Called from route handlers in place of ``render_template()``.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from typing import Any
|
|
|
|
from shared.sexp.jinja_bridge import render, load_service_components
|
|
from shared.sexp.helpers import (
|
|
call_url, root_header_html, search_desktop_html,
|
|
search_mobile_html, full_page, oob_page,
|
|
)
|
|
from shared.infrastructure.urls import market_product_url, cart_url
|
|
|
|
# Load cart-specific .sexpr components at import time
|
|
load_service_components(os.path.dirname(os.path.dirname(__file__)))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Header helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _cart_header_html(ctx: dict, *, oob: bool = False) -> str:
|
|
"""Build the cart section header row."""
|
|
return render(
|
|
"menu-row",
|
|
id="cart-row", level=1, colour="sky",
|
|
link_href=call_url(ctx, "cart_url", "/"),
|
|
link_label="cart", icon="fa fa-shopping-cart",
|
|
child_id="cart-header-child", oob=oob,
|
|
)
|
|
|
|
|
|
def _page_cart_header_html(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
|
|
"""Build the per-page cart header row."""
|
|
slug = page_post.slug if page_post else ""
|
|
title = ((page_post.title if page_post else None) or "")[:160]
|
|
label_html = ""
|
|
if page_post and page_post.feature_image:
|
|
label_html += render("cart-page-label-img", src=page_post.feature_image)
|
|
label_html += f"<span>{title}</span>"
|
|
nav_html = render("cart-all-carts-link", href=call_url(ctx, "cart_url", "/"))
|
|
return render(
|
|
"menu-row",
|
|
id="page-cart-row", level=2, colour="sky",
|
|
link_href=call_url(ctx, "cart_url", f"/{slug}/"),
|
|
link_label_html=label_html, nav_html=nav_html, oob=oob,
|
|
)
|
|
|
|
|
|
def _auth_header_html(ctx: dict, *, oob: bool = False) -> str:
|
|
"""Build the account section header row (for orders)."""
|
|
return render(
|
|
"menu-row",
|
|
id="auth-row", level=1, colour="sky",
|
|
link_href=call_url(ctx, "account_url", "/"),
|
|
link_label="account", icon="fa-solid fa-user",
|
|
child_id="auth-header-child", oob=oob,
|
|
)
|
|
|
|
|
|
def _orders_header_html(ctx: dict, list_url: str) -> str:
|
|
"""Build the orders section header row."""
|
|
return render(
|
|
"menu-row",
|
|
id="orders-row", level=2, colour="sky",
|
|
link_href=list_url, link_label="Orders", icon="fa fa-gbp",
|
|
child_id="orders-header-child",
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Cart overview
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _badge_html(icon: str, count: int, label: str) -> str:
|
|
"""Render a count badge."""
|
|
s = "s" if count != 1 else ""
|
|
return render("cart-badge", icon=icon, text=f"{count} {label}{s}")
|
|
|
|
|
|
def _page_group_card_html(grp: Any, ctx: dict) -> str:
|
|
"""Render a single page group card for cart overview."""
|
|
post = grp.get("post") if isinstance(grp, dict) else getattr(grp, "post", None)
|
|
cart_items = grp.get("cart_items", []) if isinstance(grp, dict) else getattr(grp, "cart_items", [])
|
|
cal_entries = grp.get("calendar_entries", []) if isinstance(grp, dict) else getattr(grp, "calendar_entries", [])
|
|
tickets = grp.get("tickets", []) if isinstance(grp, dict) else getattr(grp, "tickets", [])
|
|
product_count = grp.get("product_count", 0) if isinstance(grp, dict) else getattr(grp, "product_count", 0)
|
|
calendar_count = grp.get("calendar_count", 0) if isinstance(grp, dict) else getattr(grp, "calendar_count", 0)
|
|
ticket_count = grp.get("ticket_count", 0) if isinstance(grp, dict) else getattr(grp, "ticket_count", 0)
|
|
total = grp.get("total", 0) if isinstance(grp, dict) else getattr(grp, "total", 0)
|
|
market_place = grp.get("market_place") if isinstance(grp, dict) else getattr(grp, "market_place", None)
|
|
|
|
if not cart_items and not cal_entries and not tickets:
|
|
return ""
|
|
|
|
# Count badges
|
|
badges = ""
|
|
if product_count > 0:
|
|
badges += _badge_html("fa fa-box-open", product_count, "item")
|
|
if calendar_count > 0:
|
|
badges += _badge_html("fa fa-calendar", calendar_count, "booking")
|
|
if ticket_count > 0:
|
|
badges += _badge_html("fa fa-ticket", ticket_count, "ticket")
|
|
badges_html = render("cart-badges-wrap", badges_html=badges)
|
|
|
|
if post:
|
|
slug = post.slug if hasattr(post, "slug") else post.get("slug", "")
|
|
title = post.title if hasattr(post, "title") else post.get("title", "")
|
|
feature_image = post.feature_image if hasattr(post, "feature_image") else post.get("feature_image")
|
|
cart_href = call_url(ctx, "cart_url", f"/{slug}/")
|
|
|
|
if feature_image:
|
|
img = render("cart-group-card-img", src=feature_image, alt=title)
|
|
else:
|
|
img = render("cart-group-card-placeholder")
|
|
|
|
mp_sub = ""
|
|
if market_place:
|
|
mp_name = market_place.name if hasattr(market_place, "name") else market_place.get("name", "")
|
|
mp_sub = render("cart-mp-subtitle", title=title)
|
|
else:
|
|
mp_name = ""
|
|
display_title = mp_name or title
|
|
|
|
return render(
|
|
"cart-group-card",
|
|
href=cart_href, img_html=img, display_title=display_title,
|
|
subtitle_html=mp_sub, badges_html=badges_html,
|
|
total=f"\u00a3{total:.2f}",
|
|
)
|
|
else:
|
|
# Orphan items — use amber badges
|
|
badges_amber = badges.replace("bg-stone-100", "bg-amber-100")
|
|
badges_html_amber = render("cart-badges-wrap", badges_html=badges_amber)
|
|
return render(
|
|
"cart-orphan-card",
|
|
badges_html=badges_html_amber,
|
|
total=f"\u00a3{total:.2f}",
|
|
)
|
|
|
|
|
|
def _empty_cart_html() -> str:
|
|
"""Empty cart state."""
|
|
return render("cart-empty")
|
|
|
|
|
|
def _overview_main_panel_html(page_groups: list, ctx: dict) -> str:
|
|
"""Cart overview main panel."""
|
|
if not page_groups:
|
|
return _empty_cart_html()
|
|
|
|
cards = [_page_group_card_html(grp, ctx) for grp in page_groups]
|
|
has_items = any(c for c in cards)
|
|
if not has_items:
|
|
return _empty_cart_html()
|
|
|
|
return render("cart-overview-panel", cards_html="".join(cards))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Page cart
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _cart_item_html(item: Any, ctx: dict) -> str:
|
|
"""Render a single product cart item."""
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
from quart import url_for
|
|
|
|
p = item.product if hasattr(item, "product") else item
|
|
slug = p.slug if hasattr(p, "slug") else ""
|
|
unit_price = getattr(p, "special_price", None) or getattr(p, "regular_price", None)
|
|
currency = getattr(p, "regular_price_currency", "GBP") or "GBP"
|
|
symbol = "\u00a3" if currency == "GBP" else currency
|
|
csrf = generate_csrf_token()
|
|
qty_url = url_for("cart_global.update_quantity", product_id=p.id)
|
|
prod_url = market_product_url(slug)
|
|
|
|
if p.image:
|
|
img = render("cart-item-img", src=p.image, alt=p.title)
|
|
else:
|
|
img = render("cart-item-no-img")
|
|
|
|
price_html = ""
|
|
if unit_price:
|
|
price_html = render("cart-item-price", text=f"{symbol}{unit_price:.2f}")
|
|
if p.special_price and p.special_price != p.regular_price:
|
|
price_html += render("cart-item-price-was", text=f"{symbol}{p.regular_price:.2f}")
|
|
else:
|
|
price_html = render("cart-item-no-price")
|
|
|
|
deleted_html = ""
|
|
if getattr(item, "is_deleted", False):
|
|
deleted_html = render("cart-item-deleted")
|
|
|
|
brand_html = ""
|
|
if getattr(p, "brand", None):
|
|
brand_html = render("cart-item-brand", brand=p.brand)
|
|
|
|
line_total_html = ""
|
|
if unit_price:
|
|
lt = unit_price * item.quantity
|
|
line_total_html = render("cart-item-line-total", text=f"Line total: {symbol}{lt:.2f}")
|
|
|
|
return render(
|
|
"cart-item",
|
|
id=f"cart-item-{slug}", img_html=img, prod_url=prod_url, title=p.title,
|
|
brand_html=brand_html, deleted_html=deleted_html, price_html=price_html,
|
|
qty_url=qty_url, csrf=csrf, minus=str(item.quantity - 1),
|
|
qty=str(item.quantity), plus=str(item.quantity + 1),
|
|
line_total_html=line_total_html,
|
|
)
|
|
|
|
|
|
def _calendar_entries_html(entries: list) -> str:
|
|
"""Render calendar booking entries in cart."""
|
|
if not entries:
|
|
return ""
|
|
items = ""
|
|
for e in entries:
|
|
name = getattr(e, "name", None) or getattr(e, "calendar_name", "")
|
|
start = e.start_at if hasattr(e, "start_at") else ""
|
|
end = getattr(e, "end_at", None)
|
|
cost = getattr(e, "cost", 0) or 0
|
|
end_str = f" \u2013 {end}" if end else ""
|
|
items += render(
|
|
"cart-cal-entry",
|
|
name=name, date_str=f"{start}{end_str}", cost=f"\u00a3{cost:.2f}",
|
|
)
|
|
return render("cart-cal-section", items_html=items)
|
|
|
|
|
|
def _ticket_groups_html(ticket_groups: list, ctx: dict) -> str:
|
|
"""Render ticket groups in cart."""
|
|
if not ticket_groups:
|
|
return ""
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
from quart import url_for
|
|
|
|
csrf = generate_csrf_token()
|
|
qty_url = url_for("cart_global.update_ticket_quantity")
|
|
items = ""
|
|
|
|
for tg in ticket_groups:
|
|
name = tg.entry_name if hasattr(tg, "entry_name") else tg.get("entry_name", "")
|
|
tt_name = tg.ticket_type_name if hasattr(tg, "ticket_type_name") else tg.get("ticket_type_name", "")
|
|
price = tg.price if hasattr(tg, "price") else tg.get("price", 0)
|
|
quantity = tg.quantity if hasattr(tg, "quantity") else tg.get("quantity", 0)
|
|
line_total = tg.line_total if hasattr(tg, "line_total") else tg.get("line_total", 0)
|
|
entry_id = tg.entry_id if hasattr(tg, "entry_id") else tg.get("entry_id", "")
|
|
tt_id = tg.ticket_type_id if hasattr(tg, "ticket_type_id") else tg.get("ticket_type_id", "")
|
|
start_at = tg.entry_start_at if hasattr(tg, "entry_start_at") else tg.get("entry_start_at")
|
|
end_at = tg.entry_end_at if hasattr(tg, "entry_end_at") else tg.get("entry_end_at")
|
|
|
|
date_str = start_at.strftime("%-d %b %Y, %H:%M") if start_at else ""
|
|
if end_at:
|
|
date_str += f" \u2013 {end_at.strftime('%-d %b %Y, %H:%M')}"
|
|
|
|
tt_name_html = render("cart-ticket-type-name", name=tt_name) if tt_name else ""
|
|
tt_hidden = render("cart-ticket-type-hidden", value=str(tt_id)) if tt_id else ""
|
|
|
|
items += render(
|
|
"cart-ticket-article",
|
|
name=name, type_name_html=tt_name_html, date_str=date_str,
|
|
price=f"\u00a3{price or 0:.2f}", qty_url=qty_url, csrf=csrf,
|
|
entry_id=str(entry_id), type_hidden_html=tt_hidden,
|
|
minus=str(max(quantity - 1, 0)), qty=str(quantity),
|
|
plus=str(quantity + 1), line_total=f"Line total: \u00a3{line_total:.2f}",
|
|
)
|
|
|
|
return render("cart-tickets-section", items_html=items)
|
|
|
|
|
|
def _cart_summary_html(ctx: dict, cart: list, cal_entries: list, tickets: list,
|
|
total_fn: Any, cal_total_fn: Any, ticket_total_fn: Any) -> str:
|
|
"""Render the order summary sidebar."""
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
from quart import g, url_for, request
|
|
from shared.infrastructure.urls import login_url
|
|
|
|
csrf = generate_csrf_token()
|
|
product_qty = sum(ci.quantity for ci in cart) if cart else 0
|
|
ticket_qty = len(tickets) if tickets else 0
|
|
item_count = product_qty + ticket_qty
|
|
|
|
product_total = total_fn(cart) or 0
|
|
cal_total = cal_total_fn(cal_entries) or 0
|
|
tk_total = ticket_total_fn(tickets) or 0
|
|
grand = float(product_total) + float(cal_total) + float(tk_total)
|
|
|
|
symbol = "\u00a3"
|
|
if cart and hasattr(cart[0], "product") and getattr(cart[0].product, "regular_price_currency", None):
|
|
cur = cart[0].product.regular_price_currency
|
|
symbol = "\u00a3" if cur == "GBP" else cur
|
|
|
|
user = getattr(g, "user", None)
|
|
page_post = ctx.get("page_post")
|
|
|
|
if user:
|
|
if page_post:
|
|
action = url_for("page_cart.page_checkout")
|
|
else:
|
|
action = url_for("cart_global.checkout")
|
|
from shared.utils import route_prefix
|
|
action = route_prefix() + action
|
|
checkout_html = render(
|
|
"cart-checkout-form",
|
|
action=action, csrf=csrf, label=f" Checkout as {user.email}",
|
|
)
|
|
else:
|
|
href = login_url(request.url)
|
|
checkout_html = render("cart-checkout-signin", href=href)
|
|
|
|
return render(
|
|
"cart-summary-panel",
|
|
item_count=str(item_count), subtotal=f"{symbol}{grand:.2f}",
|
|
checkout_html=checkout_html,
|
|
)
|
|
|
|
|
|
def _page_cart_main_panel_html(ctx: dict, cart: list, cal_entries: list,
|
|
tickets: list, ticket_groups: list,
|
|
total_fn: Any, cal_total_fn: Any,
|
|
ticket_total_fn: Any) -> str:
|
|
"""Page cart main panel."""
|
|
if not cart and not cal_entries and not tickets:
|
|
return render("cart-page-empty")
|
|
|
|
items_html = "".join(_cart_item_html(item, ctx) for item in cart)
|
|
cal_html = _calendar_entries_html(cal_entries)
|
|
tickets_html = _ticket_groups_html(ticket_groups, ctx)
|
|
summary_html = _cart_summary_html(ctx, cart, cal_entries, tickets, total_fn, cal_total_fn, ticket_total_fn)
|
|
|
|
return render(
|
|
"cart-page-panel",
|
|
items_html=items_html, cal_html=cal_html,
|
|
tickets_html=tickets_html, summary_html=summary_html,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Orders list (same pattern as orders service)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _order_row_html(order: Any, detail_url: str) -> str:
|
|
"""Render a single order as desktop table row + mobile card."""
|
|
status = order.status or "pending"
|
|
sl = status.lower()
|
|
pill = (
|
|
"border-emerald-300 bg-emerald-50 text-emerald-700" if sl == "paid"
|
|
else "border-rose-300 bg-rose-50 text-rose-700" if sl in ("failed", "cancelled")
|
|
else "border-stone-300 bg-stone-50 text-stone-700"
|
|
)
|
|
pill_cls = f"inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] sm:text-xs {pill}"
|
|
created = order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else "\u2014"
|
|
total = f"{order.currency or 'GBP'} {order.total_amount or 0:.2f}"
|
|
|
|
desktop = render(
|
|
"cart-order-row-desktop",
|
|
order_id=f"#{order.id}", created=created, desc=order.description or "",
|
|
total=total, pill=pill_cls, status=status, detail_url=detail_url,
|
|
)
|
|
|
|
mobile_pill = f"inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] {pill}"
|
|
mobile = render(
|
|
"cart-order-row-mobile",
|
|
order_id=f"#{order.id}", pill=mobile_pill, status=status,
|
|
created=created, total=total, detail_url=detail_url,
|
|
)
|
|
|
|
return desktop + mobile
|
|
|
|
|
|
def _orders_rows_html(orders: list, page: int, total_pages: int,
|
|
url_for_fn: Any, qs_fn: Any) -> str:
|
|
"""Render order rows + infinite scroll sentinel."""
|
|
from shared.utils import route_prefix
|
|
pfx = route_prefix()
|
|
|
|
parts = [
|
|
_order_row_html(o, pfx + url_for_fn("orders.order.order_detail", order_id=o.id))
|
|
for o in orders
|
|
]
|
|
|
|
if page < total_pages:
|
|
next_url = pfx + url_for_fn("orders.list_orders") + qs_fn(page=page + 1)
|
|
parts.append(render(
|
|
"infinite-scroll",
|
|
url=next_url, page=page, total_pages=total_pages,
|
|
id_prefix="orders", colspan=5,
|
|
))
|
|
else:
|
|
parts.append(render("cart-orders-end"))
|
|
|
|
return "".join(parts)
|
|
|
|
|
|
def _orders_main_panel_html(orders: list, rows_html: str) -> str:
|
|
"""Main panel for orders list."""
|
|
if not orders:
|
|
return render("cart-orders-empty")
|
|
return render("cart-orders-table", rows_html=rows_html)
|
|
|
|
|
|
def _orders_summary_html(ctx: dict) -> str:
|
|
"""Filter section for orders list."""
|
|
return render("cart-orders-filter", search_mobile_html=search_mobile_html(ctx))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Single order detail
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _order_items_html(order: Any) -> str:
|
|
"""Render order items list."""
|
|
if not order or not order.items:
|
|
return ""
|
|
items = ""
|
|
for item in order.items:
|
|
prod_url = market_product_url(item.product_slug)
|
|
if item.product_image:
|
|
img = render(
|
|
"cart-order-item-img",
|
|
src=item.product_image, alt=item.product_title or "Product image",
|
|
)
|
|
else:
|
|
img = render("cart-order-item-no-img")
|
|
items += render(
|
|
"cart-order-item",
|
|
prod_url=prod_url, img_html=img,
|
|
title=item.product_title or "Unknown product",
|
|
product_id=f"Product ID: {item.product_id}",
|
|
qty=f"Qty: {item.quantity}",
|
|
price=f"{item.currency or order.currency or 'GBP'} {item.unit_price or 0:.2f}",
|
|
)
|
|
return render("cart-order-items-panel", items_html=items)
|
|
|
|
|
|
def _order_summary_html(order: Any) -> str:
|
|
"""Order summary card."""
|
|
return render(
|
|
"order-summary-card",
|
|
order_id=order.id,
|
|
created_at=order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else None,
|
|
description=order.description, status=order.status, currency=order.currency,
|
|
total_amount=f"{order.total_amount:.2f}" if order.total_amount else None,
|
|
)
|
|
|
|
|
|
def _order_calendar_items_html(calendar_entries: list | None) -> str:
|
|
"""Render calendar bookings for an order."""
|
|
if not calendar_entries:
|
|
return ""
|
|
items = ""
|
|
for e in calendar_entries:
|
|
st = e.state or ""
|
|
pill = (
|
|
"bg-emerald-100 text-emerald-800" if st == "confirmed"
|
|
else "bg-amber-100 text-amber-800" if st == "provisional"
|
|
else "bg-blue-100 text-blue-800" if st == "ordered"
|
|
else "bg-stone-100 text-stone-700"
|
|
)
|
|
pill_cls = f"inline-flex items-center rounded-full px-2 py-0.5 text-[11px] font-medium {pill}"
|
|
ds = e.start_at.strftime("%-d %b %Y, %H:%M") if e.start_at else ""
|
|
if e.end_at:
|
|
ds += f" \u2013 {e.end_at.strftime('%-d %b %Y, %H:%M')}"
|
|
items += render(
|
|
"cart-order-cal-entry",
|
|
name=e.name, pill=pill_cls, status=st.capitalize(),
|
|
date_str=ds, cost=f"\u00a3{e.cost or 0:.2f}",
|
|
)
|
|
return render("cart-order-cal-section", items_html=items)
|
|
|
|
|
|
def _order_main_html(order: Any, calendar_entries: list | None) -> str:
|
|
"""Main panel for single order detail."""
|
|
summary = _order_summary_html(order)
|
|
return render(
|
|
"cart-order-main",
|
|
summary_html=summary, items_html=_order_items_html(order),
|
|
cal_html=_order_calendar_items_html(calendar_entries),
|
|
)
|
|
|
|
|
|
def _order_filter_html(order: Any, list_url: str, recheck_url: str,
|
|
pay_url: str, csrf_token: str) -> str:
|
|
"""Filter section for single order detail."""
|
|
created = order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else "\u2014"
|
|
status = order.status or "pending"
|
|
|
|
pay = ""
|
|
if status != "paid":
|
|
pay = render("cart-order-pay-btn", url=pay_url)
|
|
|
|
return render(
|
|
"cart-order-filter",
|
|
info=f"Placed {created} \u00b7 Status: {status}",
|
|
list_url=list_url, recheck_url=recheck_url, csrf=csrf_token, pay_html=pay,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Cart overview
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_overview_page(ctx: dict, page_groups: list) -> str:
|
|
"""Full page: cart overview."""
|
|
main = _overview_main_panel_html(page_groups, ctx)
|
|
hdr = root_header_html(ctx)
|
|
return full_page(ctx, header_rows_html=hdr, content_html=main)
|
|
|
|
|
|
async def render_overview_oob(ctx: dict, page_groups: list) -> str:
|
|
"""OOB response for cart overview."""
|
|
main = _overview_main_panel_html(page_groups, ctx)
|
|
oobs = root_header_html(ctx, oob=True)
|
|
return oob_page(ctx, oobs_html=oobs, content_html=main)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Page cart
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_page_cart_page(ctx: dict, page_post: Any,
|
|
cart: list, cal_entries: list, tickets: list,
|
|
ticket_groups: list, total_fn: Any,
|
|
cal_total_fn: Any, ticket_total_fn: Any) -> str:
|
|
"""Full page: page-specific cart."""
|
|
main = _page_cart_main_panel_html(ctx, cart, cal_entries, tickets, ticket_groups,
|
|
total_fn, cal_total_fn, ticket_total_fn)
|
|
hdr = root_header_html(ctx)
|
|
child = _cart_header_html(ctx)
|
|
page_hdr = _page_cart_header_html(ctx, page_post)
|
|
hdr += render(
|
|
"cart-header-child-nested",
|
|
outer_html=child, inner_html=page_hdr,
|
|
)
|
|
return full_page(ctx, header_rows_html=hdr, content_html=main)
|
|
|
|
|
|
async def render_page_cart_oob(ctx: dict, page_post: Any,
|
|
cart: list, cal_entries: list, tickets: list,
|
|
ticket_groups: list, total_fn: Any,
|
|
cal_total_fn: Any, ticket_total_fn: Any) -> str:
|
|
"""OOB response for page cart."""
|
|
main = _page_cart_main_panel_html(ctx, cart, cal_entries, tickets, ticket_groups,
|
|
total_fn, cal_total_fn, ticket_total_fn)
|
|
oobs = (
|
|
render("cart-header-child-oob", inner_html=_page_cart_header_html(ctx, page_post))
|
|
+ _cart_header_html(ctx, oob=True)
|
|
+ root_header_html(ctx, oob=True)
|
|
)
|
|
return oob_page(ctx, oobs_html=oobs, content_html=main)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Orders list
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_orders_page(ctx: dict, orders: list, page: int,
|
|
total_pages: int, search: str | None,
|
|
search_count: int, url_for_fn: Any,
|
|
qs_fn: Any) -> str:
|
|
"""Full page: orders list."""
|
|
from shared.utils import route_prefix
|
|
|
|
ctx["search"] = search
|
|
ctx["search_count"] = search_count
|
|
list_url = route_prefix() + url_for_fn("orders.list_orders")
|
|
|
|
rows = _orders_rows_html(orders, page, total_pages, url_for_fn, qs_fn)
|
|
main = _orders_main_panel_html(orders, rows)
|
|
|
|
hdr = root_header_html(ctx)
|
|
hdr += render(
|
|
"cart-auth-header-child",
|
|
auth_html=_auth_header_html(ctx),
|
|
orders_html=_orders_header_html(ctx, list_url),
|
|
)
|
|
|
|
return full_page(ctx, header_rows_html=hdr,
|
|
filter_html=_orders_summary_html(ctx),
|
|
aside_html=search_desktop_html(ctx),
|
|
content_html=main)
|
|
|
|
|
|
async def render_orders_rows(ctx: dict, orders: list, page: int,
|
|
total_pages: int, url_for_fn: Any,
|
|
qs_fn: Any) -> str:
|
|
"""Pagination: just the table rows."""
|
|
return _orders_rows_html(orders, page, total_pages, url_for_fn, qs_fn)
|
|
|
|
|
|
async def render_orders_oob(ctx: dict, orders: list, page: int,
|
|
total_pages: int, search: str | None,
|
|
search_count: int, url_for_fn: Any,
|
|
qs_fn: Any) -> str:
|
|
"""OOB response for orders list."""
|
|
from shared.utils import route_prefix
|
|
|
|
ctx["search"] = search
|
|
ctx["search_count"] = search_count
|
|
list_url = route_prefix() + url_for_fn("orders.list_orders")
|
|
|
|
rows = _orders_rows_html(orders, page, total_pages, url_for_fn, qs_fn)
|
|
main = _orders_main_panel_html(orders, rows)
|
|
|
|
oobs = (
|
|
_auth_header_html(ctx, oob=True)
|
|
+ render(
|
|
"cart-auth-header-child-oob",
|
|
inner_html=_orders_header_html(ctx, list_url),
|
|
)
|
|
+ root_header_html(ctx, oob=True)
|
|
)
|
|
|
|
return oob_page(ctx, oobs_html=oobs,
|
|
filter_html=_orders_summary_html(ctx),
|
|
aside_html=search_desktop_html(ctx),
|
|
content_html=main)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Single order detail
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_order_page(ctx: dict, order: Any,
|
|
calendar_entries: list | None,
|
|
url_for_fn: Any) -> str:
|
|
"""Full page: single order detail."""
|
|
from shared.utils import route_prefix
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
|
|
pfx = route_prefix()
|
|
detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
|
|
list_url = pfx + url_for_fn("orders.list_orders")
|
|
recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
|
|
pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
|
|
|
|
main = _order_main_html(order, calendar_entries)
|
|
filt = _order_filter_html(order, list_url, recheck_url, pay_url, generate_csrf_token())
|
|
|
|
hdr = root_header_html(ctx)
|
|
order_row = render(
|
|
"menu-row",
|
|
id="order-row", level=3, colour="sky",
|
|
link_href=detail_url, link_label=f"Order {order.id}", icon="fa fa-gbp",
|
|
)
|
|
hdr += render(
|
|
"cart-order-header-child",
|
|
auth_html=_auth_header_html(ctx),
|
|
orders_html=_orders_header_html(ctx, list_url),
|
|
order_html=order_row,
|
|
)
|
|
|
|
return full_page(ctx, header_rows_html=hdr, filter_html=filt, content_html=main)
|
|
|
|
|
|
async def render_order_oob(ctx: dict, order: Any,
|
|
calendar_entries: list | None,
|
|
url_for_fn: Any) -> str:
|
|
"""OOB response for single order detail."""
|
|
from shared.utils import route_prefix
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
|
|
pfx = route_prefix()
|
|
detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
|
|
list_url = pfx + url_for_fn("orders.list_orders")
|
|
recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
|
|
pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
|
|
|
|
main = _order_main_html(order, calendar_entries)
|
|
filt = _order_filter_html(order, list_url, recheck_url, pay_url, generate_csrf_token())
|
|
|
|
order_row_oob = render(
|
|
"menu-row",
|
|
id="order-row", level=3, colour="sky",
|
|
link_href=detail_url, link_label=f"Order {order.id}", icon="fa fa-gbp",
|
|
oob=True,
|
|
)
|
|
oobs = (
|
|
render("cart-orders-header-child-oob", inner_html=order_row_oob)
|
|
+ root_header_html(ctx, oob=True)
|
|
)
|
|
|
|
return oob_page(ctx, oobs_html=oobs, filter_html=filt, content_html=main)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Checkout error
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _checkout_error_filter_html() -> str:
|
|
return render("cart-checkout-error-filter")
|
|
|
|
|
|
def _checkout_error_content_html(error: str | None, order: Any | None) -> str:
|
|
err_msg = error or "Unexpected error while creating the hosted checkout session."
|
|
order_html = ""
|
|
if order:
|
|
order_html = render("cart-checkout-error-order-id", order_id=f"#{order.id}")
|
|
back_url = cart_url("/")
|
|
return render(
|
|
"cart-checkout-error-content",
|
|
error_msg=err_msg, order_html=order_html, back_url=back_url,
|
|
)
|
|
|
|
|
|
async def render_checkout_error_page(ctx: dict, error: str | None = None, order: Any | None = None) -> str:
|
|
"""Full page: checkout error."""
|
|
hdr = root_header_html(ctx)
|
|
filt = _checkout_error_filter_html()
|
|
content = _checkout_error_content_html(error, order)
|
|
return full_page(ctx, header_rows_html=hdr, filter_html=filt, content_html=content)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Page admin (/<page_slug>/admin/)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _cart_page_admin_header_html(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
|
|
"""Build the page-level admin header row."""
|
|
from quart import url_for
|
|
link_href = url_for("page_admin.admin")
|
|
return render("menu-row", id="page-admin-row", level=2, colour="sky",
|
|
link_href=link_href, link_label="admin", icon="fa fa-cog",
|
|
child_id="page-admin-header-child", oob=oob)
|
|
|
|
|
|
def _cart_payments_header_html(ctx: dict, *, oob: bool = False) -> str:
|
|
"""Build the payments section header row."""
|
|
from quart import url_for
|
|
link_href = url_for("page_admin.payments")
|
|
return render("menu-row", id="payments-row", level=3, colour="sky",
|
|
link_href=link_href, link_label="Payments",
|
|
icon="fa fa-credit-card",
|
|
child_id="payments-header-child", oob=oob)
|
|
|
|
|
|
def _cart_admin_main_panel_html(ctx: dict) -> str:
|
|
"""Admin overview panel — links to sub-admin pages."""
|
|
from quart import url_for
|
|
payments_href = url_for("page_admin.payments")
|
|
return (
|
|
'<div id="main-panel">'
|
|
'<div class="flex items-center justify-between p-3 border-b">'
|
|
'<span class="font-medium"><i class="fa fa-credit-card text-purple-600 mr-1"></i> Payments</span>'
|
|
f'<a href="{payments_href}" class="text-sm underline">configure</a>'
|
|
'</div>'
|
|
'</div>'
|
|
)
|
|
|
|
|
|
def _cart_payments_main_panel_html(ctx: dict) -> str:
|
|
"""Render SumUp payment config form."""
|
|
from quart import url_for
|
|
csrf_token = ctx.get("csrf_token")
|
|
csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
|
|
page_config = ctx.get("page_config")
|
|
sumup_configured = bool(page_config and getattr(page_config, "sumup_api_key", None))
|
|
merchant_code = (getattr(page_config, "sumup_merchant_code", None) or "") if page_config else ""
|
|
checkout_prefix = (getattr(page_config, "sumup_checkout_prefix", None) or "") if page_config else ""
|
|
update_url = url_for("page_admin.update_sumup")
|
|
|
|
placeholder = "--------" if sumup_configured else "sup_sk_..."
|
|
input_cls = "w-full px-3 py-1.5 text-sm border border-stone-300 rounded focus:ring-purple-500 focus:border-purple-500"
|
|
|
|
return render("cart-payments-panel",
|
|
update_url=update_url, csrf=csrf,
|
|
merchant_code=merchant_code, placeholder=placeholder,
|
|
input_cls=input_cls, sumup_configured=sumup_configured,
|
|
checkout_prefix=checkout_prefix)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Cart page admin
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_cart_admin_page(ctx: dict, page_post: Any) -> str:
|
|
"""Full page: cart page admin overview."""
|
|
content = _cart_admin_main_panel_html(ctx)
|
|
hdr = root_header_html(ctx)
|
|
child = _page_cart_header_html(ctx, page_post) + _cart_page_admin_header_html(ctx, page_post)
|
|
hdr += render("cart-header-child-nested",
|
|
outer_html=_cart_header_html(ctx), inner_html=child)
|
|
return full_page(ctx, header_rows_html=hdr, content_html=content)
|
|
|
|
|
|
async def render_cart_admin_oob(ctx: dict, page_post: Any) -> str:
|
|
"""OOB response: cart page admin overview."""
|
|
content = _cart_admin_main_panel_html(ctx)
|
|
oobs = (
|
|
_cart_page_admin_header_html(ctx, page_post, oob=True)
|
|
+ render("cart-header-child-oob",
|
|
inner_html=_page_cart_header_html(ctx, page_post)
|
|
+ _cart_page_admin_header_html(ctx, page_post))
|
|
+ _cart_header_html(ctx, oob=True)
|
|
+ root_header_html(ctx, oob=True)
|
|
)
|
|
return oob_page(ctx, oobs_html=oobs, content_html=content)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API: Cart payments admin
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def render_cart_payments_page(ctx: dict, page_post: Any) -> str:
|
|
"""Full page: payments config."""
|
|
content = _cart_payments_main_panel_html(ctx)
|
|
hdr = root_header_html(ctx)
|
|
admin_hdr = _cart_page_admin_header_html(ctx, page_post)
|
|
payments_hdr = _cart_payments_header_html(ctx)
|
|
child = _page_cart_header_html(ctx, page_post) + admin_hdr + payments_hdr
|
|
hdr += render("cart-header-child-nested",
|
|
outer_html=_cart_header_html(ctx), inner_html=child)
|
|
return full_page(ctx, header_rows_html=hdr, content_html=content)
|
|
|
|
|
|
async def render_cart_payments_oob(ctx: dict, page_post: Any) -> str:
|
|
"""OOB response: payments config."""
|
|
content = _cart_payments_main_panel_html(ctx)
|
|
admin_hdr = _cart_page_admin_header_html(ctx, page_post)
|
|
payments_hdr = _cart_payments_header_html(ctx)
|
|
oobs = (
|
|
_cart_payments_header_html(ctx, oob=True)
|
|
+ render("cart-header-child-oob",
|
|
inner_html=_page_cart_header_html(ctx, page_post)
|
|
+ admin_hdr + payments_hdr)
|
|
+ _cart_header_html(ctx, oob=True)
|
|
+ root_header_html(ctx, oob=True)
|
|
)
|
|
return oob_page(ctx, oobs_html=oobs, content_html=content)
|
|
|
|
|
|
def render_cart_payments_panel(ctx: dict) -> str:
|
|
"""Render the payments config panel for PUT response."""
|
|
return _cart_payments_main_panel_html(ctx)
|