| """Curology's stateful, zero-remote WebsiteBench clone.""" |
|
|
| from __future__ import annotations |
|
|
| from functools import lru_cache |
| from pathlib import Path |
| from typing import Any |
|
|
| from fastapi import FastAPI, Request |
| from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse |
| from fastapi.staticfiles import StaticFiles |
| from pydantic import BaseModel, Field |
|
|
| import ui |
| from backend.curology_store import ( |
| CurologyPermissionError, |
| CurologyStore, |
| CurologyTransitionError, |
| CurologyValidationError, |
| ) |
| from backend.site_backend_integration import open_site_services |
| from websitebench.local_clone_auth import AuthError, LocalAuthStore |
| from websitebench.site_backend import PaymentError, SiteBackend |
|
|
|
|
| SITE_ID = "curology" |
| DISPLAY_NAME = "Curology" |
| STATIC_ROOT = Path(__file__).resolve().parent / "static" |
| app = FastAPI(title=DISPLAY_NAME, docs_url=None, redoc_url=None) |
| app.mount("/static", StaticFiles(directory=STATIC_ROOT), name="static") |
|
|
|
|
| @app.get("/robots.txt", response_class=PlainTextResponse) |
| def robots_txt() -> str: |
| return "User-agent: *\nDisallow:\n" |
|
|
|
|
| @app.get("/llms.txt", response_class=PlainTextResponse) |
| def llms_txt() -> str: |
| return """# Curology offline WebsiteBench simulation |
| |
| > Public routes are local-only. No medical care or external transaction occurs. |
| |
| ## Public local pages |
| |
| - [Home](/) |
| - [Products](/shop) |
| - [Why Curology](/why-curology) |
| - [Reviews](/reviews) |
| - [Skincare 101](/skincare-101) |
| """ |
|
|
|
|
| @lru_cache(maxsize=1) |
| def services() -> tuple[SiteBackend, LocalAuthStore, CurologyStore]: |
| backend, auth = open_site_services() |
| store = CurologyStore(backend, auth) |
| store.seed_demo() |
| return backend, auth, store |
|
|
|
|
| class Context: |
| def __init__(self, request: Request) -> None: |
| self.backend, self.auth, self.store = services() |
| cookie_name = self.backend.session_cookie["name"] |
| self.incoming_token = request.cookies.get(cookie_name) |
| self.token, self.session = self.auth.ensure_session(self.incoming_token) |
| digest = self.auth.session_owner_digest(self.token) |
| self.actor = self.store.actor(self.session, digest) |
|
|
| @property |
| def account(self) -> dict[str, Any] | None: |
| return self.actor.account |
|
|
| def set_token(self, token: str) -> None: |
| self.token = token |
| resolved = self.auth.resolve_session(token) |
| if resolved is None: |
| raise RuntimeError("rotated local session was not persisted") |
| self.session = resolved |
| digest = self.auth.session_owner_digest(token) |
| self.actor = self.store.actor(resolved, digest) |
|
|
| def apply_cookie(self, response: Any) -> None: |
| if self.token == self.incoming_token: |
| return |
| facts = self.backend.session_cookie |
| response.set_cookie( |
| key=str(facts["name"]), |
| value=self.token, |
| secure=bool(facts["secure"]), |
| httponly=bool(facts["httponly"]), |
| samesite=str(facts["samesite"]).lower(), |
| path=str(facts["path"]), |
| ) |
|
|
|
|
| def page( |
| request: Request, |
| renderer: Any, |
| *args: Any, |
| status_code: int = 200, |
| ) -> HTMLResponse: |
| context = Context(request) |
| response = HTMLResponse( |
| renderer(context.account, *args), |
| status_code=status_code, |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| def api_response( |
| context: Context, payload: dict[str, Any], *, status_code: int = 200 |
| ) -> JSONResponse: |
| response = JSONResponse(payload, status_code=status_code) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| def api_error(context: Context, exc: Exception, *, status_code: int = 400) -> JSONResponse: |
| return api_response(context, {"detail": str(exc)}, status_code=status_code) |
|
|
|
|
| def require_account_page(request: Request, next_url: str) -> tuple[Context, RedirectResponse | None]: |
| context = Context(request) |
| if context.actor.authenticated: |
| return context, None |
| response = RedirectResponse(f"/auth/login?next={next_url}", status_code=303) |
| context.apply_cookie(response) |
| return context, response |
|
|
|
|
| def safe_next(value: str) -> str: |
| return value if value.startswith("/") and not value.startswith("//") else "/account" |
|
|
|
|
| class AnswerPayload(BaseModel): |
| value: str |
| idempotency_key: str |
|
|
|
|
| class PlanPayload(BaseModel): |
| plan_tier: str |
| quantity: int = Field(ge=1, le=4) |
| frequency: str |
| product_option: str |
| idempotency_key: str |
|
|
|
|
| class ShippingPayload(BaseModel): |
| name: str |
| address: str |
| city: str |
| region: str |
| postal: str |
| email: str |
| idempotency_key: str |
|
|
|
|
| class PaymentPayload(BaseModel): |
| scenario_id: str |
| fingerprint: str = Field(min_length=64, max_length=64) |
| idempotency_key: str |
|
|
|
|
| class IdempotentPayload(BaseModel): |
| idempotency_key: str |
|
|
|
|
| class ModifyPayload(IdempotentPayload): |
| plan_tier: str |
| quantity: int = Field(ge=1, le=4) |
| frequency: str |
| product_option: str |
|
|
|
|
| class ReschedulePayload(IdempotentPayload): |
| delivery_date: str |
|
|
|
|
| class LoginPayload(BaseModel): |
| email: str |
| password: str |
|
|
|
|
| class RegistrationStartPayload(BaseModel): |
| display_name: str |
| email: str |
| password: str |
| terms: str |
|
|
|
|
| class CodePayload(BaseModel): |
| code: str |
|
|
|
|
| class RecoveryStartPayload(BaseModel): |
| email: str |
|
|
|
|
| class RecoveryCompletePayload(BaseModel): |
| code: str |
| new_password: str |
|
|
|
|
| class ContactPayload(BaseModel): |
| topic: str |
| message: str |
| idempotency_key: str |
|
|
|
|
| @app.get("/healthz") |
| def healthz() -> dict[str, object]: |
| backend, _, _ = services() |
| return { |
| "ok": True, |
| "site_id": SITE_ID, |
| "database": backend.lifecycle.health()["status"], |
| "payment_adapter": backend.config.payments["default_adapter"], |
| "remote_runtime_requests": "forbidden", |
| } |
|
|
|
|
| @app.get("/", response_class=HTMLResponse) |
| def home(request: Request) -> HTMLResponse: |
| return page(request, ui.home) |
|
|
|
|
| @app.get("/shop", response_class=HTMLResponse) |
| def shop( |
| request: Request, |
| q: str = "", |
| category: str = "", |
| concern: str = "", |
| sort: str = "featured", |
| ) -> HTMLResponse: |
| return page(request, ui.shop, q[:120], category[:40], concern[:40], sort[:40]) |
|
|
|
|
| @app.get("/shop/{slug}", response_class=HTMLResponse) |
| def shop_product_detail(request: Request, slug: str) -> HTMLResponse: |
| if slug not in ui.PRODUCT_BY_SLUG: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
| return page(request, ui.product_detail, slug) |
|
|
|
|
| @app.get("/products/custom-formula-acne/", response_class=HTMLResponse) |
| def formula(request: Request) -> HTMLResponse: |
| return page(request, ui.formula) |
|
|
|
|
| @app.get("/products/{slug}/", response_class=HTMLResponse) |
| def product_detail(request: Request, slug: str) -> HTMLResponse: |
| if slug not in ui.PRODUCT_BY_SLUG: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
| return page(request, ui.product_detail, slug) |
|
|
|
|
| @app.get("/sign-up/start/face", response_class=HTMLResponse) |
| def quiz_welcome(request: Request) -> HTMLResponse: |
| return page(request, ui.quiz_welcome) |
|
|
|
|
| @app.get("/quiz/questionnaire/{step}", response_class=HTMLResponse) |
| def questionnaire(request: Request, step: str) -> HTMLResponse: |
| if step not in ui.QUESTION_COPY: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
| context = Context(request) |
| state = context.store.state(context.actor.owner) |
| response = HTMLResponse(ui.questionnaire(context.account, state, step)) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/plans", response_class=HTMLResponse) |
| def plans(request: Request) -> HTMLResponse: |
| context = Context(request) |
| response = HTMLResponse( |
| ui.plans(context.account, context.store.state(context.actor.owner)) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/checkout/shipping", response_class=HTMLResponse) |
| def checkout_shipping(request: Request) -> HTMLResponse: |
| context = Context(request) |
| response = HTMLResponse( |
| ui.shipping(context.account, context.store.state(context.actor.owner)) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/checkout/payment", response_class=HTMLResponse) |
| def checkout_payment(request: Request) -> HTMLResponse: |
| context = Context(request) |
| response = HTMLResponse( |
| ui.payment(context.account, context.store.state(context.actor.owner)) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/checkout/review", response_class=HTMLResponse) |
| def checkout_review(request: Request) -> HTMLResponse: |
| context = Context(request) |
| response = HTMLResponse( |
| ui.review(context.account, context.store.state(context.actor.owner)) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/auth/login", response_class=HTMLResponse) |
| def login_page( |
| request: Request, email: str = "", next: str = "/account" |
| ) -> HTMLResponse: |
| return page(request, ui.login, email[:254], safe_next(next)) |
|
|
|
|
| @app.get("/auth/register", response_class=HTMLResponse) |
| def register_page(request: Request) -> HTMLResponse: |
| return page(request, ui.register, safe_next(request.query_params.get("next", "/account"))) |
|
|
|
|
| @app.get("/auth/recover", response_class=HTMLResponse) |
| def recover_page(request: Request) -> HTMLResponse: |
| return page(request, ui.recovery) |
|
|
|
|
| @app.get("/account", response_class=HTMLResponse) |
| def account_page(request: Request) -> Any: |
| context, redirect = require_account_page(request, "/account") |
| if redirect: |
| return redirect |
| response = HTMLResponse( |
| ui.account_dashboard( |
| context.account or {}, |
| context.store.dashboard(context.actor.owner), |
| context.store.state(context.actor.owner), |
| ) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/account/address", response_class=HTMLResponse) |
| def account_address_page(request: Request) -> Any: |
| context, redirect = require_account_page(request, "/account/address") |
| if redirect: |
| return redirect |
| response = HTMLResponse( |
| ui.account_address( |
| context.account or {}, context.store.state(context.actor.owner) |
| ) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/account/subscription", response_class=HTMLResponse) |
| def subscription_page(request: Request) -> Any: |
| context, redirect = require_account_page(request, "/account/subscription") |
| if redirect: |
| return redirect |
| response = HTMLResponse( |
| ui.subscription( |
| context.account or {}, context.store.dashboard(context.actor.owner) |
| ) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/account/orders", response_class=HTMLResponse) |
| def orders_page(request: Request) -> Any: |
| context, redirect = require_account_page(request, "/account/orders") |
| if redirect: |
| return redirect |
| response = HTMLResponse( |
| ui.orders(context.account or {}, context.store.dashboard(context.actor.owner)) |
| ) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/account/orders/{order_id}", response_class=HTMLResponse) |
| def order_detail_page(request: Request, order_id: str) -> Any: |
| context, redirect = require_account_page(request, f"/account/orders/{order_id}") |
| if redirect: |
| return redirect |
| data = context.store.dashboard(context.actor.owner) |
| item = next( |
| (order for order in data["orders"] if order["order_id"] == order_id), |
| None, |
| ) |
| if item is None: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
| response = HTMLResponse(ui.order_detail(context.account or {}, item)) |
| context.apply_cookie(response) |
| return response |
|
|
|
|
| @app.get("/help", response_class=HTMLResponse) |
| def help_page(request: Request, q: str = "") -> HTMLResponse: |
| return page(request, ui.help_page) |
|
|
|
|
| @app.get("/skincare-101", response_class=HTMLResponse) |
| def skincare_101_page( |
| request: Request, topic: str = "", q: str = "" |
| ) -> HTMLResponse: |
| return page(request, ui.skincare_101, topic[:40], q[:120]) |
|
|
|
|
| @app.get("/skincare-101/articles/{slug}", response_class=HTMLResponse) |
| def skincare_article_page(request: Request, slug: str) -> HTMLResponse: |
| response = page(request, ui.skincare_article, slug) |
| if slug not in {item[4] for item in ui.ARTICLES}: |
| response.status_code = 404 |
| return response |
|
|
|
|
| @app.get("/contact", response_class=HTMLResponse) |
| def contact_page(request: Request) -> HTMLResponse: |
| return page(request, ui.contact_page) |
|
|
|
|
| @app.get("/why-curology", response_class=HTMLResponse) |
| def why_page(request: Request) -> HTMLResponse: |
| return page(request, ui.why_curology) |
|
|
|
|
| @app.get("/reviews", response_class=HTMLResponse) |
| def reviews_page(request: Request) -> HTMLResponse: |
| return page(request, ui.reviews_page) |
|
|
|
|
| @app.get("/skincare/reviews/", response_class=HTMLResponse) |
| def reviews_source_path(request: Request) -> HTMLResponse: |
| return page(request, ui.reviews_page) |
|
|
|
|
| @app.get("/about/{slug}", response_class=HTMLResponse) |
| def about_page(request: Request, slug: str) -> HTMLResponse: |
| pages = { |
| "careers": ("Careers", "Explore how teams build accessible, personalized skincare experiences."), |
| "press": ("Press room", "Find local background on Curology's personalized skincare model and public milestones."), |
| } |
| if slug not in pages: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
| title, copy = pages[slug] |
| return page(request, ui.simple_page, title, copy) |
|
|
|
|
| @app.get("/terms", response_class=HTMLResponse) |
| def terms_page(request: Request) -> HTMLResponse: |
| return page( |
| request, |
| ui.simple_page, |
| "Terms of Service", |
| "Use only synthetic information. Local activation has no relationship to a real Curology subscription.", |
| ) |
|
|
|
|
| @app.get("/privacy", response_class=HTMLResponse) |
| def privacy_page(request: Request) -> HTMLResponse: |
| return page(request, ui.privacy_page) |
|
|
|
|
| @app.post("/api/questionnaire/{step}") |
| def answer_question( |
| request: Request, step: str, payload: AnswerPayload |
| ) -> JSONResponse: |
| context = Context(request) |
| dimensions = { |
| "skin-type": "skin_type", |
| "acne": "acne_concern", |
| "aging": "aging_concern", |
| } |
| if step not in dimensions: |
| return api_response(context, {"detail": "Question not found."}, status_code=404) |
| try: |
| value = context.store.answer( |
| context.actor.owner, |
| dimension=dimensions[step], |
| value=payload.value, |
| idempotency_key=payload.idempotency_key, |
| ) |
| return api_response(context, value) |
| except CurologyValidationError as exc: |
| return api_error(context, exc) |
|
|
|
|
| @app.post("/api/plan") |
| def choose_plan(request: Request, payload: PlanPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| return api_response( |
| context, |
| context.store.select_plan( |
| context.actor.owner, |
| plan_tier=payload.plan_tier, |
| quantity=payload.quantity, |
| frequency=payload.frequency, |
| product_option=payload.product_option, |
| idempotency_key=payload.idempotency_key, |
| ), |
| ) |
| except CurologyValidationError as exc: |
| return api_error(context, exc) |
|
|
|
|
| @app.post("/api/shipping") |
| def save_shipping(request: Request, payload: ShippingPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| return api_response( |
| context, |
| context.store.save_shipping( |
| context.actor.owner, |
| fields={ |
| "name": payload.name, |
| "address": payload.address, |
| "city": payload.city, |
| "region": payload.region, |
| "postal": payload.postal, |
| "email": payload.email, |
| }, |
| idempotency_key=payload.idempotency_key, |
| ), |
| ) |
| except CurologyValidationError as exc: |
| return api_error(context, exc) |
|
|
|
|
| @app.post("/api/payment") |
| def simulate_payment(request: Request, payload: PaymentPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| result = context.store.attempt_payment( |
| context.actor.owner, |
| scenario_id=payload.scenario_id, |
| fingerprint=payload.fingerprint, |
| idempotency_key=payload.idempotency_key, |
| ) |
| code = 200 if result["ok"] else 409 |
| result["detail"] = { |
| "DECLINED": "The simulated payment was declined. Choose approval or retry.", |
| "RETRYABLE": "The simulated payment is retryable. Try again with a new attempt.", |
| }.get(str(result["status"]), "Saved local payment simulation.") |
| return api_response(context, result, status_code=code) |
| except (CurologyValidationError, PaymentError) as exc: |
| return api_error(context, exc) |
|
|
|
|
| @app.post("/api/activate") |
| def activate(request: Request, payload: IdempotentPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| return api_response( |
| context, |
| context.store.activate( |
| context.actor, idempotency_key=payload.idempotency_key |
| ), |
| ) |
| except CurologyPermissionError as exc: |
| return api_error(context, exc, status_code=403) |
| except (CurologyValidationError, CurologyTransitionError, PaymentError) as exc: |
| return api_error(context, exc, status_code=409) |
|
|
|
|
| @app.post("/api/auth/login") |
| def sign_in(request: Request, payload: LoginPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| result = context.auth.sign_in( |
| context.token, |
| email=payload.email, |
| password=payload.password, |
| session_rotation_callback=context.store.rotate_actor_state, |
| ) |
| context.set_token(str(result["session_token"])) |
| return api_response(context, {"ok": True, "account": result["account"]}) |
| except AuthError: |
| return api_response( |
| context, {"detail": "Email or password is incorrect."}, status_code=401 |
| ) |
|
|
|
|
| @app.post("/api/auth/logout") |
| def sign_out(request: Request) -> JSONResponse: |
| context = Context(request) |
| context.auth.sign_out(context.token) |
| new_token, _ = context.auth.ensure_session(None) |
| context.set_token(new_token) |
| return api_response(context, {"ok": True, "message": "Logged out locally."}) |
|
|
|
|
| @app.post("/api/auth/register/start") |
| def registration_start( |
| request: Request, payload: RegistrationStartPayload |
| ) -> JSONResponse: |
| context = Context(request) |
| if payload.terms != "accepted": |
| return api_response( |
| context, {"detail": "Accept the local terms to continue."}, status_code=400 |
| ) |
| try: |
| context.auth.start_registration( |
| context.token, |
| email=payload.email, |
| display_name=payload.display_name, |
| password=payload.password, |
| ) |
| message = context.auth.local_mail_for_session( |
| context.token, purpose="registration" |
| ) |
| return api_response( |
| context, |
| { |
| "ok": True, |
| "message": "Saved to the local outbox. No email was sent.", |
| "mail_status": "LOCAL_ONLY", |
| "local_preview_code": message["verification_code"] if message else None, |
| }, |
| ) |
| except AuthError as exc: |
| return api_error(context, exc, status_code=409) |
|
|
|
|
| @app.post("/api/auth/register/verify") |
| def registration_verify(request: Request, payload: CodePayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| context.auth.verify_registration_code(context.token, payload.code) |
| result = context.auth.complete_registration( |
| context.token, |
| session_rotation_callback=context.store.rotate_actor_state, |
| ) |
| context.set_token(str(result["session_token"])) |
| return api_response(context, {"ok": True, "account": result["account"]}) |
| except AuthError as exc: |
| return api_error(context, exc, status_code=400) |
|
|
|
|
| @app.post("/api/auth/recovery/start") |
| def recovery_start( |
| request: Request, payload: RecoveryStartPayload |
| ) -> JSONResponse: |
| context = Context(request) |
| try: |
| result = context.auth.start_password_reset(context.token, email=payload.email) |
| message = context.auth.local_mail_for_session( |
| context.token, purpose="password-reset" |
| ) |
| return api_response( |
| context, |
| { |
| "ok": True, |
| "message": result["message"], |
| "mail_status": "LOCAL_ONLY" if message else "NOT_CREATED", |
| "local_preview_code": message["verification_code"] if message else None, |
| }, |
| ) |
| except AuthError as exc: |
| return api_error(context, exc, status_code=400) |
|
|
|
|
| @app.post("/api/auth/recovery/complete") |
| def recovery_complete( |
| request: Request, payload: RecoveryCompletePayload |
| ) -> JSONResponse: |
| context = Context(request) |
| try: |
| context.auth.verify_password_reset_code(context.token, payload.code) |
| new_token = context.auth.complete_password_reset( |
| context.token, |
| new_password=payload.new_password, |
| session_rotation_callback=context.store.rotate_actor_state, |
| ) |
| context.set_token(new_token) |
| return api_response(context, {"ok": True, "message": "Password updated locally."}) |
| except AuthError as exc: |
| return api_error(context, exc, status_code=400) |
|
|
|
|
| def manage_response( |
| request: Request, |
| action: str, |
| payload: IdempotentPayload, |
| values: dict[str, Any] | None = None, |
| ) -> JSONResponse: |
| context = Context(request) |
| try: |
| return api_response( |
| context, |
| context.store.manage( |
| context.actor, |
| action=action, |
| idempotency_key=payload.idempotency_key, |
| values=values, |
| ), |
| ) |
| except CurologyPermissionError as exc: |
| return api_error(context, exc, status_code=403) |
| except (CurologyValidationError, CurologyTransitionError) as exc: |
| return api_error(context, exc, status_code=409) |
|
|
|
|
| @app.post("/api/subscription/modify") |
| def modify_subscription(request: Request, payload: ModifyPayload) -> JSONResponse: |
| return manage_response( |
| request, |
| "modify", |
| payload, |
| { |
| "plan_tier": payload.plan_tier, |
| "quantity": payload.quantity, |
| "frequency": payload.frequency, |
| "product_option": payload.product_option, |
| }, |
| ) |
|
|
|
|
| @app.post("/api/subscription/pause") |
| def pause_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse: |
| return manage_response(request, "pause", payload) |
|
|
|
|
| @app.post("/api/subscription/skip") |
| def skip_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse: |
| return manage_response(request, "skip", payload) |
|
|
|
|
| @app.post("/api/subscription/reschedule") |
| def reschedule_subscription( |
| request: Request, payload: ReschedulePayload |
| ) -> JSONResponse: |
| return manage_response( |
| request, "reschedule", payload, {"delivery_date": payload.delivery_date} |
| ) |
|
|
|
|
| @app.post("/api/subscription/cancel") |
| def cancel_subscription(request: Request, payload: IdempotentPayload) -> JSONResponse: |
| return manage_response(request, "cancel", payload) |
|
|
|
|
| @app.post("/api/subscription/reactivate") |
| def reactivate_subscription( |
| request: Request, payload: IdempotentPayload |
| ) -> JSONResponse: |
| return manage_response(request, "reactivate", payload) |
|
|
|
|
| @app.post("/api/contact") |
| def save_contact(request: Request, payload: ContactPayload) -> JSONResponse: |
| context = Context(request) |
| try: |
| return api_response( |
| context, |
| context.store.contact( |
| context.actor.owner, |
| topic=payload.topic, |
| message=payload.message, |
| idempotency_key=payload.idempotency_key, |
| ), |
| ) |
| except CurologyValidationError as exc: |
| return api_error(context, exc) |
|
|
|
|
| @app.get("/{path:path}", response_class=HTMLResponse) |
| def unknown(request: Request, path: str) -> HTMLResponse: |
| return page(request, ui.not_found, request.url.path, status_code=404) |
|
|
