giles
293f7713d6
Some checks failed
Build and Deploy / build-and-deploy (push) Failing after 16s
Defpages are now declared with absolute paths in .sx files and auto-mounted directly on the Quart app, removing ~850 lines of blueprint mount_pages calls, before_request hooks, and g.* wrapper boilerplate. A new page = one defpage declaration, nothing else. Infrastructure: - async_eval awaits coroutine results from callable dispatch - auto_mount_pages() mounts all registered defpages on the app - g._defpage_ctx pattern passes helper data to layout context Migrated: sx, account, orders, federation, cart, market, events, blog Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
345 lines
12 KiB
Python
345 lines
12 KiB
Python
"""Orders defpage setup — registers layouts, page helpers, and loads .sx pages."""
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
|
|
def setup_orders_pages() -> None:
|
|
"""Register orders-specific layouts, page helpers, and load page definitions."""
|
|
_register_orders_layouts()
|
|
_register_orders_helpers()
|
|
_load_orders_page_files()
|
|
|
|
|
|
def _load_orders_page_files() -> None:
|
|
"""Load defpage definitions from orders/sxc/pages/*.sx."""
|
|
import os
|
|
from shared.sx.pages import load_page_dir
|
|
load_page_dir(os.path.dirname(__file__), "orders")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Layouts
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _register_orders_layouts() -> None:
|
|
from shared.sx.layouts import register_custom_layout
|
|
register_custom_layout("orders", _orders_full, _orders_oob, _orders_mobile)
|
|
register_custom_layout("order-detail", _order_detail_full, _order_detail_oob, _order_detail_mobile)
|
|
|
|
|
|
def _orders_full(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import root_header_sx, header_child_sx
|
|
from sx.sx_components import _auth_header_sx, _orders_header_sx
|
|
|
|
list_url = kw.get("list_url", "/")
|
|
root_hdr = root_header_sx(ctx)
|
|
inner = "(<> " + _auth_header_sx(ctx) + " " + _orders_header_sx(ctx, list_url) + ")"
|
|
return "(<> " + root_hdr + " " + header_child_sx(inner) + ")"
|
|
|
|
|
|
def _orders_oob(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import root_header_sx, sx_call, SxExpr
|
|
from sx.sx_components import _auth_header_sx, _orders_header_sx
|
|
|
|
list_url = kw.get("list_url", "/")
|
|
auth_hdr = _auth_header_sx(ctx, oob=True)
|
|
auth_child_oob = sx_call("oob-header-sx",
|
|
parent_id="auth-header-child",
|
|
row=SxExpr(_orders_header_sx(ctx, list_url)))
|
|
root_hdr = root_header_sx(ctx, oob=True)
|
|
return "(<> " + auth_hdr + " " + auth_child_oob + " " + root_hdr + ")"
|
|
|
|
|
|
def _orders_mobile(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import mobile_menu_sx, mobile_root_nav_sx
|
|
return mobile_menu_sx(mobile_root_nav_sx(ctx))
|
|
|
|
|
|
def _order_detail_full(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import root_header_sx, sx_call, SxExpr
|
|
from sx.sx_components import _auth_header_sx, _orders_header_sx
|
|
|
|
list_url = kw.get("list_url", "/")
|
|
detail_url = kw.get("detail_url", "/")
|
|
root_hdr = root_header_sx(ctx)
|
|
order_row = sx_call(
|
|
"menu-row-sx",
|
|
id="order-row", level=3, colour="sky", link_href=detail_url,
|
|
link_label="Order", icon="fa fa-gbp",
|
|
)
|
|
detail_header = sx_call(
|
|
"order-detail-header-stack",
|
|
auth=SxExpr(_auth_header_sx(ctx)),
|
|
orders=SxExpr(_orders_header_sx(ctx, list_url)),
|
|
order=SxExpr(order_row),
|
|
)
|
|
return "(<> " + root_hdr + " " + detail_header + ")"
|
|
|
|
|
|
def _order_detail_oob(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import root_header_sx, sx_call, SxExpr
|
|
|
|
detail_url = kw.get("detail_url", "/")
|
|
order_row_oob = sx_call(
|
|
"menu-row-sx",
|
|
id="order-row", level=3, colour="sky", link_href=detail_url,
|
|
link_label="Order", icon="fa fa-gbp", oob=True,
|
|
)
|
|
header_child_oob = sx_call("oob-header-sx",
|
|
parent_id="orders-header-child",
|
|
row=SxExpr(order_row_oob))
|
|
root_hdr = root_header_sx(ctx, oob=True)
|
|
return "(<> " + header_child_oob + " " + root_hdr + ")"
|
|
|
|
|
|
def _order_detail_mobile(ctx: dict, **kw: Any) -> str:
|
|
from shared.sx.helpers import mobile_menu_sx, mobile_root_nav_sx
|
|
return mobile_menu_sx(mobile_root_nav_sx(ctx))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Page helpers — Python functions callable from defpage expressions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _register_orders_helpers() -> None:
|
|
from shared.sx.pages import register_page_helpers
|
|
|
|
register_page_helpers("orders", {
|
|
# Orders list
|
|
"orders-list-content": _h_orders_list_content,
|
|
"orders-list-filter": _h_orders_list_filter,
|
|
"orders-list-aside": _h_orders_list_aside,
|
|
"orders-list-url": _h_orders_list_url,
|
|
# Order detail
|
|
"order-detail-content": _h_order_detail_content,
|
|
"order-detail-filter": _h_order_detail_filter,
|
|
"order-detail-url": _h_order_detail_url,
|
|
"order-list-url-from-detail": _h_order_list_url_from_detail,
|
|
})
|
|
|
|
|
|
async def _ensure_orders_list():
|
|
"""Fetch orders list data and store in g.orders_page_data."""
|
|
from quart import g, url_for
|
|
if hasattr(g, "orders_page_data"):
|
|
return
|
|
from sqlalchemy import select, func, or_, cast, String, exists
|
|
from shared.models.order import Order, OrderItem
|
|
from shared.infrastructure.cart_identity import current_cart_identity
|
|
from shared.utils import route_prefix
|
|
|
|
ORDERS_PER_PAGE = 10
|
|
ident = current_cart_identity()
|
|
if ident["user_id"]:
|
|
owner_clause = Order.user_id == ident["user_id"]
|
|
elif ident["session_id"]:
|
|
owner_clause = Order.session_id == ident["session_id"]
|
|
else:
|
|
g.orders_page_data = None
|
|
return
|
|
|
|
from bp.orders.filters.qs import makeqs_factory, decode
|
|
q = decode()
|
|
page, search = q.page, q.search
|
|
if page < 1:
|
|
page = 1
|
|
|
|
where_clause = None
|
|
if search:
|
|
term = f"%{search.strip()}%"
|
|
conditions = [
|
|
Order.status.ilike(term),
|
|
Order.currency.ilike(term),
|
|
Order.sumup_checkout_id.ilike(term),
|
|
Order.sumup_status.ilike(term),
|
|
Order.description.ilike(term),
|
|
]
|
|
conditions.append(
|
|
exists(
|
|
select(1).select_from(OrderItem)
|
|
.where(OrderItem.order_id == Order.id,
|
|
or_(OrderItem.product_title.ilike(term),
|
|
OrderItem.product_slug.ilike(term)))
|
|
)
|
|
)
|
|
try:
|
|
search_id = int(search)
|
|
except (TypeError, ValueError):
|
|
search_id = None
|
|
if search_id is not None:
|
|
conditions.append(Order.id == search_id)
|
|
else:
|
|
conditions.append(cast(Order.id, String).ilike(term))
|
|
where_clause = or_(*conditions)
|
|
|
|
count_stmt = select(func.count()).select_from(Order).where(owner_clause)
|
|
if where_clause is not None:
|
|
count_stmt = count_stmt.where(where_clause)
|
|
|
|
total_count_result = await g.s.execute(count_stmt)
|
|
total_count = total_count_result.scalar_one() or 0
|
|
total_pages = max(1, (total_count + ORDERS_PER_PAGE - 1) // ORDERS_PER_PAGE)
|
|
if page > total_pages:
|
|
page = total_pages
|
|
|
|
offset = (page - 1) * ORDERS_PER_PAGE
|
|
stmt = (
|
|
select(Order).where(owner_clause)
|
|
.order_by(Order.created_at.desc())
|
|
.offset(offset).limit(ORDERS_PER_PAGE)
|
|
)
|
|
if where_clause is not None:
|
|
stmt = stmt.where(where_clause)
|
|
|
|
result = await g.s.execute(stmt)
|
|
orders = result.scalars().all()
|
|
pfx = route_prefix()
|
|
qs_fn = makeqs_factory()
|
|
|
|
g.orders_page_data = {
|
|
"orders": orders,
|
|
"page": page,
|
|
"total_pages": total_pages,
|
|
"search": search,
|
|
"search_count": total_count,
|
|
"url_for_fn": url_for,
|
|
"qs_fn": qs_fn,
|
|
"list_url": pfx + url_for("defpage_orders_list"),
|
|
}
|
|
|
|
|
|
async def _ensure_order_detail(order_id):
|
|
"""Fetch order detail data and store in g.order_detail_data."""
|
|
from quart import g, url_for, abort
|
|
if hasattr(g, "order_detail_data"):
|
|
return
|
|
from sqlalchemy import select
|
|
from sqlalchemy.orm import selectinload
|
|
from shared.models.order import Order
|
|
from shared.infrastructure.cart_identity import current_cart_identity
|
|
from shared.utils import route_prefix
|
|
from shared.browser.app.csrf import generate_csrf_token
|
|
|
|
if order_id is None:
|
|
abort(404)
|
|
|
|
ident = current_cart_identity()
|
|
if ident["user_id"]:
|
|
owner = Order.user_id == ident["user_id"]
|
|
elif ident["session_id"]:
|
|
owner = Order.session_id == ident["session_id"]
|
|
else:
|
|
abort(404)
|
|
return
|
|
|
|
result = await g.s.execute(
|
|
select(Order).options(selectinload(Order.items))
|
|
.where(Order.id == order_id, owner)
|
|
)
|
|
order = result.scalar_one_or_none()
|
|
if not order:
|
|
abort(404)
|
|
return
|
|
|
|
pfx = route_prefix()
|
|
g.order_detail_data = {
|
|
"order": order,
|
|
"calendar_entries": None,
|
|
"detail_url": pfx + url_for("defpage_order_detail", order_id=order.id),
|
|
"list_url": pfx + url_for("defpage_orders_list"),
|
|
"recheck_url": pfx + url_for("orders.order.order_recheck", order_id=order.id),
|
|
"pay_url": pfx + url_for("orders.order.order_pay", order_id=order.id),
|
|
"csrf_token": generate_csrf_token(),
|
|
}
|
|
|
|
|
|
async def _h_orders_list_content(**kw):
|
|
await _ensure_orders_list()
|
|
from quart import g
|
|
d = getattr(g, "orders_page_data", None)
|
|
if not d:
|
|
from shared.sx.helpers import sx_call
|
|
return sx_call("order-empty-state")
|
|
from sx.sx_components import _orders_rows_sx, _orders_main_panel_sx
|
|
rows = _orders_rows_sx(d["orders"], d["page"], d["total_pages"],
|
|
d["url_for_fn"], d["qs_fn"])
|
|
return _orders_main_panel_sx(d["orders"], rows)
|
|
|
|
|
|
async def _h_orders_list_filter(**kw):
|
|
await _ensure_orders_list()
|
|
from quart import g
|
|
from shared.sx.helpers import sx_call, SxExpr
|
|
from shared.sx.page import SEARCH_HEADERS_MOBILE
|
|
d = getattr(g, "orders_page_data", None)
|
|
search = d.get("search", "") if d else ""
|
|
search_count = d.get("search_count", "") if d else ""
|
|
search_mobile = sx_call("search-mobile",
|
|
current_local_href="/",
|
|
search=search or "",
|
|
search_count=search_count or "",
|
|
hx_select="#main-panel",
|
|
search_headers_mobile=SEARCH_HEADERS_MOBILE,
|
|
)
|
|
return sx_call("order-list-header", search_mobile=SxExpr(search_mobile))
|
|
|
|
|
|
async def _h_orders_list_aside(**kw):
|
|
await _ensure_orders_list()
|
|
from quart import g
|
|
from shared.sx.helpers import sx_call
|
|
from shared.sx.page import SEARCH_HEADERS_DESKTOP
|
|
d = getattr(g, "orders_page_data", None)
|
|
search = d.get("search", "") if d else ""
|
|
search_count = d.get("search_count", "") if d else ""
|
|
return sx_call("search-desktop",
|
|
current_local_href="/",
|
|
search=search or "",
|
|
search_count=search_count or "",
|
|
hx_select="#main-panel",
|
|
search_headers_desktop=SEARCH_HEADERS_DESKTOP,
|
|
)
|
|
|
|
|
|
async def _h_orders_list_url(**kw):
|
|
await _ensure_orders_list()
|
|
from quart import g
|
|
d = getattr(g, "orders_page_data", None)
|
|
return d["list_url"] if d else "/"
|
|
|
|
|
|
async def _h_order_detail_content(order_id=None, **kw):
|
|
await _ensure_order_detail(order_id)
|
|
from quart import g
|
|
d = getattr(g, "order_detail_data", None)
|
|
if not d:
|
|
return ""
|
|
from sx.sx_components import _order_main_sx
|
|
return _order_main_sx(d["order"], d["calendar_entries"])
|
|
|
|
|
|
async def _h_order_detail_filter(order_id=None, **kw):
|
|
await _ensure_order_detail(order_id)
|
|
from quart import g
|
|
d = getattr(g, "order_detail_data", None)
|
|
if not d:
|
|
return ""
|
|
from sx.sx_components import _order_filter_sx
|
|
return _order_filter_sx(d["order"], d["list_url"], d["recheck_url"],
|
|
d["pay_url"], d["csrf_token"])
|
|
|
|
|
|
async def _h_order_detail_url(order_id=None, **kw):
|
|
await _ensure_order_detail(order_id)
|
|
from quart import g
|
|
d = getattr(g, "order_detail_data", None)
|
|
return d["detail_url"] if d else "/"
|
|
|
|
|
|
async def _h_order_list_url_from_detail(order_id=None, **kw):
|
|
await _ensure_order_detail(order_id)
|
|
from quart import g
|
|
d = getattr(g, "order_detail_data", None)
|
|
return d["list_url"] if d else "/"
|