Split cart into 4 microservices: relations, likes, orders, page-config→blog

Phase 1 - Relations service (internal): owns ContainerRelation, exposes
get-children data + attach/detach-child actions. Retargeted events, blog,
market callers from cart to relations.

Phase 2 - Likes service (internal): unified Like model replaces ProductLike
and PostLike with generic target_type/target_slug/target_id. Exposes
is-liked, liked-slugs, liked-ids data + toggle action.

Phase 3 - PageConfig → blog: moved ownership to blog with direct DB queries,
removed proxy endpoints from cart.

Phase 4 - Orders service (public): owns Order/OrderItem + SumUp checkout
flow. Cart checkout now delegates to orders via create-order action.
Webhook/return routes and reconciliation moved to orders.

Phase 5 - Infrastructure: docker-compose, deploy.sh, Dockerfiles updated
for all 3 new services. Added orders_url helper and factory model imports.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

orders/bp/order/filters/qs.py

@@ -0,0 +1,74 @@
+# suma_browser/app/bp/order/filters/qs.py
+from quart import request
+
+from typing import Iterable, Optional, Union
+
+from shared.browser.app.filters.qs_base import KEEP, build_qs
+from shared.browser.app.filters.query_types import OrderQuery
+
+
+def decode() -> OrderQuery:
+    """
+    Decode current query string into an OrderQuery(page, search).
+    """
+    try:
+        page = int(request.args.get("page", 1) or 1)
+    except ValueError:
+        page = 1
+
+    search = request.args.get("search") or None
+    return OrderQuery(page, search)
+
+
+def makeqs_factory():
+    """
+    Build a makeqs(...) that starts from the current filters + page.
+
+    Behaviour:
+    - If filters change and you don't explicitly pass page,
+      the page is reset to 1 (same pattern as browse/blog).
+    - You can clear search with search=None.
+    """
+    q = decode()
+    base_search = q.search or None
+    base_page = int(q.page or 1)
+
+    def makeqs(
+        *,
+        clear_filters: bool = False,
+        search: Union[str, None, object] = KEEP,
+        page: Union[int, None, object] = None,
+        extra: Optional[Iterable[tuple]] = None,
+        leading_q: bool = True,
+    ) -> str:
+        filters_changed = False
+
+        # --- search logic ---
+        if search is KEEP and not clear_filters:
+            final_search = base_search
+        else:
+            filters_changed = True
+            final_search = (search or None)
+
+        # --- page logic ---
+        if page is None:
+            final_page = 1 if filters_changed else base_page
+        else:
+            final_page = page
+
+        # --- build params ---
+        params: list[tuple[str, str]] = []
+
+        if final_search:
+            params.append(("search", final_search))
+        if final_page is not None:
+            params.append(("page", str(final_page)))
+
+        if extra:
+            for k, v in extra:
+                if v is not None:
+                    params.append((k, str(v)))
+
+        return build_qs(params, leading_q=leading_q)
+
+    return makeqs

orders/bp/order/routes.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from quart import Blueprint, g, render_template, redirect, url_for, make_response
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
+
+from shared.models.order import Order
+from shared.browser.app.payments.sumup import create_checkout as sumup_create_checkout
+from shared.config import config
+
+from shared.infrastructure.cart_identity import current_cart_identity
+from services.check_sumup_status import check_sumup_status
+from shared.browser.app.utils.htmx import is_htmx_request
+
+from .filters.qs import makeqs_factory, decode
+
+
+def _owner_filter():
+    """Return SQLAlchemy clause restricting orders to current user/session."""
+    ident = current_cart_identity()
+    if ident["user_id"]:
+        return Order.user_id == ident["user_id"]
+    if ident["session_id"]:
+        return Order.session_id == ident["session_id"]
+    return None
+
+
+def register() -> Blueprint:
+    bp = Blueprint("order", __name__, url_prefix='/<int:order_id>')
+
+    @bp.before_request
+    def route():
+        g.makeqs_factory = makeqs_factory
+
+    @bp.get("/")
+    async def order_detail(order_id: int):
+        """Show a single order + items."""
+        owner = _owner_filter()
+        if owner is None:
+            return await make_response("Order not found", 404)
+        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:
+            return await make_response("Order not found", 404)
+        if not is_htmx_request():
+            html = await render_template("_types/order/index.html", order=order)
+        else:
+            html = await render_template("_types/order/_oob_elements.html", order=order)
+        return await make_response(html)
+
+    @bp.get("/pay/")
+    async def order_pay(order_id: int):
+        """Re-open the SumUp payment page for this order."""
+        owner = _owner_filter()
+        if owner is None:
+            return await make_response("Order not found", 404)
+        result = await g.s.execute(select(Order).where(Order.id == order_id, owner))
+        order = result.scalar_one_or_none()
+        if not order:
+            return await make_response("Order not found", 404)
+
+        if order.status == "paid":
+            return redirect(url_for("orders.order.order_detail", order_id=order.id))
+
+        if order.sumup_hosted_url:
+            return redirect(order.sumup_hosted_url)
+
+        redirect_url = url_for("checkout.checkout_return", order_id=order.id, _external=True)
+        sumup_cfg = config().get("sumup", {}) or {}
+        webhook_secret = sumup_cfg.get("webhook_secret")
+        webhook_url = url_for("checkout.checkout_webhook", order_id=order.id, _external=True)
+        if webhook_secret:
+            from urllib.parse import urlencode
+            sep = "&" if "?" in webhook_url else "?"
+            webhook_url = f"{webhook_url}{sep}{urlencode({'token': webhook_secret})}"
+
+        checkout_data = await sumup_create_checkout(
+            order,
+            redirect_url=redirect_url,
+            webhook_url=webhook_url,
+        )
+        order.sumup_checkout_id = checkout_data.get("id")
+        order.sumup_status = checkout_data.get("status")
+        hosted_cfg = checkout_data.get("hosted_checkout") or {}
+        hosted_url = hosted_cfg.get("hosted_checkout_url") or checkout_data.get("hosted_checkout_url")
+        order.sumup_hosted_url = hosted_url
+        await g.s.flush()
+
+        if not hosted_url:
+            html = await render_template(
+                "_types/cart/checkout_error.html",
+                order=order,
+                error="No hosted checkout URL returned from SumUp when trying to reopen payment.",
+            )
+            return await make_response(html, 500)
+
+        return redirect(hosted_url)
+
+    @bp.post("/recheck/")
+    async def order_recheck(order_id: int):
+        """Manually re-check this order's status with SumUp."""
+        owner = _owner_filter()
+        if owner is None:
+            return await make_response("Order not found", 404)
+        result = await g.s.execute(select(Order).where(Order.id == order_id, owner))
+        order = result.scalar_one_or_none()
+        if not order:
+            return await make_response("Order not found", 404)
+
+        if not order.sumup_checkout_id:
+            return redirect(url_for("orders.order.order_detail", order_id=order.id))
+
+        try:
+            await check_sumup_status(g.s, order)
+        except Exception:
+            pass
+
+        return redirect(url_for("orders.order.order_detail", order_id=order.id))
+
+    return bp