"""WebsiteBench offline clone of the L.L.Bean desktop storefront. Route patterns, DOM class names, copy and layout reproduce evidence captured with Playwright in the Mac Chrome session; see ``materials/llbean/scope/notes/``. All data is served from the local site-bound SQLite database. The running clone issues no request to any remote origin. """ from __future__ import annotations import json import os import sqlite3 import sys from contextlib import contextmanager from pathlib import Path from typing import Any, Iterator from fastapi import Depends, FastAPI, Form, Request from fastapi.responses import ( FileResponse, HTMLResponse, JSONResponse, RedirectResponse, ) from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates CLONE_ROOT = Path(__file__).resolve().parent sys.path.insert(0, str(CLONE_ROOT)) from backend import repo # noqa: E402 from backend.catalog import SORT_FIELDS, VIEW_COUNT # noqa: E402 from backend.site_backend_integration import open_site_services # noqa: E402 SITE_ID = "llbean" DISPLAY_NAME = "L.L.Bean" SESSION_COOKIE = "__Host-llbean_session" STORE_FINDER_ID = 1000001703 # Lead paragraph each editorial lander opens with on the source. The heading is # repeated in the source copy block; it is dropped here because the page already # renders it as the H1. LANDER_INTRO = { 518571: ( "We always have something exciting planned! Check back often to see " "what\u2019s happening in our home state of Maine, on the road, out in " "nature, and right outside your door!" ), 518342: ( "Great products make it easier to get outside. Great advice can too. " "Welcome to the ultimate destination for expert ideas, inspiring stories, " "and how-to guides for everything outdoors." ), } app = FastAPI(title=DISPLAY_NAME, docs_url=None, redoc_url=None) app.mount( "/static", StaticFiles(directory=str(CLONE_ROOT / "frontend" / "static")), name="static" ) templates = Jinja2Templates(directory=str(CLONE_ROOT / "frontend" / "templates")) def _bind_sandbox_data_dir() -> None: """Honour the diagnostic harness's isolated data directory. ``websitebench-offline-clone verify`` boots the clone with a fresh ``WEBSITEBENCH_DATA_DIR`` and no write access to the repository tree, so the database has to live there. The filename still comes from the frozen runtime contract, which the integration seam re-validates. """ if os.environ.get("WEBSITEBENCH_SITE_BACKEND_DATABASE"): return data_dir = os.environ.get("WEBSITEBENCH_DATA_DIR") if not data_dir: return runtime = json.loads( (CLONE_ROOT.parent / "backend" / "runtime.json").read_text(encoding="utf-8") ) filename = runtime["database"]["filename"] target = Path(data_dir) target.mkdir(parents=True, exist_ok=True) os.environ["WEBSITEBENCH_SITE_BACKEND_DATABASE"] = str(target / filename) _bind_sandbox_data_dir() backend, auth = open_site_services() DB_PATH = backend.lifecycle.database_path # Synthetic fixture account for this offline clone only. It exists so the # signed-in surfaces are reachable during review and in tests; the address is on # the reserved .test TLD and the password unlocks nothing outside this local # SQLite database. No real credential is stored anywhere in this repository. DEMO_EMAIL = "outdoors@example.test" DEMO_PASSWORD = "TrailPass!2026" # noqa: S105 - synthetic local fixture DEMO_NAME = "Riley" def _bootstrap_demo_account() -> None: try: if not auth.account_exists(email=DEMO_EMAIL): auth.seed_account( subject_id="member-demo", email=DEMO_EMAIL, display_name=DEMO_NAME, password=DEMO_PASSWORD, ) except TypeError: try: auth.seed_account( subject_id="member-demo", email=DEMO_EMAIL, display_name=DEMO_NAME, password=DEMO_PASSWORD, ) except Exception: # pragma: no cover - already seeded pass except Exception: # pragma: no cover - already seeded pass _bootstrap_demo_account() @contextmanager def db_session() -> Iterator[sqlite3.Connection]: # check_same_thread=False because FastAPI runs a sync generator dependency # in its threadpool and can close it on a different worker thread than the # one that opened it. Each request still gets its own connection, so the # connection is never shared between concurrent requests. connection = sqlite3.connect(DB_PATH, check_same_thread=False, timeout=15) connection.row_factory = sqlite3.Row # WAL lets readers run while one writer commits; without it every page view # (which reads the bag) contends with any in-flight cart write. connection.execute("PRAGMA journal_mode=WAL") connection.execute("PRAGMA busy_timeout=15000") connection.execute("PRAGMA synchronous=NORMAL") try: yield connection connection.commit() finally: connection.close() def get_db() -> Iterator[sqlite3.Connection]: with db_session() as connection: yield connection class Viewer: """The current actor: an anonymous visitor or a signed-in member.""" def __init__(self, token: str, session: dict[str, Any] | None) -> None: self.token = token self.session = session or {} account = self.session.get("account") or {} authenticated = bool(self.session.get("authenticated")) and bool(account) self.subject = account.get("subject_id") if authenticated else None self.display_name = account.get("display_name") if authenticated else None self.email = account.get("email_normalized") if authenticated else None @property def signed_in(self) -> bool: return bool(self.subject) @property def owner_key(self) -> str: return f"member:{self.subject}" if self.signed_in else f"guest:{self.token}" @property def owner(self) -> str: return self.owner_key def get_viewer(request: Request) -> Viewer: """Resolve the actor, minting a real anonymous session when needed. ``ensure_session`` both validates an existing token and creates one, so an unknown or expired cookie value never leaves the request without a session. """ token, session = auth.ensure_session(request.cookies.get(SESSION_COOKIE)) return Viewer(token, session) def _set_session_cookie(response: Any, token: str) -> Any: response.set_cookie( SESSION_COOKIE, token, httponly=True, secure=True, samesite="lax", path="/", ) return response def _asset_version() -> str: """Newest mtime across the styles and templates, as a cache-busting stamp. Without it a reviewer keeps seeing a stale stylesheet after a redeploy. """ newest = 0.0 for folder in ("frontend/static/css", "frontend/static", "frontend/templates"): base = CLONE_ROOT / folder for path in base.glob("*"): if path.is_file(): newest = max(newest, path.stat().st_mtime) return str(int(newest)) def render( request: Request, template: str, viewer: Viewer, db: sqlite3.Connection, context: dict[str, Any] | None = None, status_code: int = 200, ) -> HTMLResponse: base = { "request": request, "viewer": viewer, "nav": repo.nav_menu(db), "bag_count": repo.bag_count(db, viewer.owner_key), "site_name": DISPLAY_NAME, "asset_version": _asset_version(), } base.update(context or {}) response = templates.TemplateResponse( request, template, base, status_code=status_code ) return _set_session_cookie(response, viewer.token) def _multi(request: Request, name: str) -> list[str]: return [v for v in request.query_params.getlist(name) if v] # --------------------------------------------------------------------------- # health and diagnostics # --------------------------------------------------------------------------- @app.get("/favicon.ico", include_in_schema=False) def favicon() -> FileResponse: """Browsers request this on every page; serve the site icon, not a 404.""" return FileResponse(CLONE_ROOT / "frontend" / "static" / "favicon.ico") @app.get("/healthz") def healthz() -> dict[str, object]: return {"ok": True, "site_id": SITE_ID} @app.get("/__websitebench/health") def harbor_health() -> JSONResponse: return JSONResponse({"status": "ok", "site_id": SITE_ID}) # --------------------------------------------------------------------------- # home # --------------------------------------------------------------------------- @app.get("/", response_class=HTMLResponse) def home( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: sections = repo.home_sections(db) # Two sections are personalised on the source; both are driven here by real # local data rather than a fixed list. top_picks = repo.collection( db, sort_field="bestselling", view_count=6 )["products"] seen = repo.recently_viewed(db, viewer.owner, limit=6) return render( request, "home.html", viewer, db, { "sections": sections, "top_picks": top_picks, "recently_viewed": seen, "video_asset": "/static/video/boat-and-tote.mp4", # The video's own first frame. It is what the section shows before # the loop starts, and all a reduced-motion visitor ever sees. "video_poster": "/static/img/home/boat-and-tote-poster.jpg", # The source home page collapses the rotating global banner; interior # routes render it. "hide_global_banner": True, }, ) # --------------------------------------------------------------------------- # category / product (one id namespace, dispatched by id type, as on the source) # --------------------------------------------------------------------------- @app.get("/llb/shop/{entity_id}", response_class=HTMLResponse) def shop( request: Request, entity_id: int, page: str | None = None, sort_field: str = "relevance", start: int = 0, viewCount: int = VIEW_COUNT, isLoadMore: bool = False, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: if entity_id == STORE_FINDER_ID: return _stores_page(request, db, viewer, request.query_params.get("term", "")) product = repo.product(db, str(entity_id)) if product is not None: repo.record_view(db, viewer.owner, product["product_id"]) return _product_page(request, db, viewer, product) cat = repo.category(db, entity_id) if cat is None: page = repo.content_page(db, entity_id) if page is not None: return render( request, "content.html", viewer, db, {"page": page, "sitemap": repo.category_tree(db) if entity_id == 518766 else None}, ) return render(request, "not_found.html", viewer, db, {}, status_code=404) # An editorial lander (Outdoor Experiences, Explore L.L.Bean) has no grid. lander = repo.lander(db, entity_id) if lander is not None: return render( request, "lander.html", viewer, db, { "category": cat, "lander": lander, "intro": LANDER_INTRO.get(entity_id), "active_cat_id": entity_id, "active_root_id": entity_id, }, ) colors = _multi(request, "color") brands = _multi(request, "brand") bands = _multi(request, "price") genders = _multi(request, "gender") sizes = _multi(request, "size") materials = _multi(request, "material") percent_off = _multi(request, "percent_off") on_sale = request.query_params.get("sale") == "1" is_new = request.query_params.get("new") == "1" batch = repo.collection( db, cat_id=entity_id, colors=colors, brands=brands, price_bands=bands, on_sale=on_sale, is_new=is_new, genders=genders, sizes=sizes, materials=materials, percent_off=percent_off, sort_field=sort_field, start=start, view_count=viewCount, ) # A "load more" batch keeps every earlier batch on the page, as the source does. if start: first = repo.collection( db, cat_id=entity_id, colors=colors, brands=brands, price_bands=bands, on_sale=on_sale, is_new=is_new, genders=genders, sizes=sizes, materials=materials, percent_off=percent_off, sort_field=sort_field, start=0, view_count=start, ) batch["products"] = first["products"] + batch["products"] return render( request, "category.html", viewer, db, { "category": cat, "subcategories": repo.children(db, entity_id), "ancestors": repo.ancestors(db, entity_id), "active_cat_id": entity_id, "active_root_id": (repo.ancestors(db, entity_id) or [{}])[0].get("cat_id"), "batch": batch, "facets": repo.facets(db, cat_id=entity_id), "selected": { "color": colors, "brand": brands, "price": bands, "gender": genders, "size": sizes, "material": materials, "percent_off": percent_off, "sale": on_sale, "new": is_new, "sort_field": sort_field, }, "sort_options": SORT_FIELDS, "is_load_more": bool(isLoadMore), }, ) def _product_page( request: Request, db: sqlite3.Connection, viewer: Viewer, product: dict[str, Any], *, message: str | None = None, error: str | None = None, added: bool = False, ) -> HTMLResponse: review_sort = request.query_params.get("review_sort", "recent") star = request.query_params.get("star") limit = int(request.query_params.get("review_limit", 10) or 10) review_data = repo.reviews( db, product["product_id"], limit=limit, star=int(star) if star and star.isdigit() else None, sort=review_sort, ) related = repo.collection( db, cat_id=29, sort_field="bestselling", view_count=4 )["products"] return render( request, "product.html", viewer, db, { "product": product, "reviews": review_data, "review_sort": review_sort, "review_star": star, "review_limit": limit, "related": [r for r in related if r["product_id"] != product["product_id"]][:3], "message": message, "error": error, "added": added, "selected_color": request.query_params.get("color"), "selected_size": request.query_params.get("size"), }, ) # --------------------------------------------------------------------------- # search # --------------------------------------------------------------------------- @app.get("/llb/search", response_class=HTMLResponse) def search( request: Request, freeText: str = "", sort_field: str = "relevance", start: int = 0, viewCount: int = VIEW_COUNT, tab: str = "products", db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: query = (freeText or "").strip() colors = _multi(request, "color") brands = _multi(request, "brand") bands = _multi(request, "price") on_sale = request.query_params.get("sale") == "1" batch = repo.collection( db, query=query or None, colors=colors, brands=brands, price_bands=bands, on_sale=on_sale, sort_field=sort_field, start=start, view_count=viewCount, ) if start: first = repo.collection( db, query=query or None, colors=colors, brands=brands, price_bands=bands, on_sale=on_sale, sort_field=sort_field, start=0, view_count=start, ) batch["products"] = first["products"] + batch["products"] content = repo.content_pages(db, query or None) popular = repo.collection(db, cat_id=29, sort_field="bestselling", view_count=6)["products"] return render( request, "search.html", viewer, db, { "query": query, "batch": batch, "content": content, "tab": tab, "facets": repo.facets(db, query=query or None), "selected": { "color": colors, "brand": brands, "price": bands, "sale": on_sale, "sort_field": sort_field, }, "sort_options": SORT_FIELDS, "popular": popular, }, ) # --------------------------------------------------------------------------- # shopping bag # --------------------------------------------------------------------------- @app.post("/cart/add") def cart_add( request: Request, product_id: str = Form(...), color: str | None = Form(None), size: str | None = Form(None), quantity: int = Form(1), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: product = repo.product(db, product_id) if product is None: return render(request, "not_found.html", viewer, db, {}, status_code=404) try: repo.add_to_cart( db, viewer.owner_key, product_id=product_id, color=color, size=size, qty=quantity, ) except ValueError as exc: return _product_page(request, db, viewer, product, error=str(exc)) db.commit() refreshed = repo.product(db, product_id) assert refreshed is not None return _product_page(request, db, viewer, refreshed, added=True) @app.get("/shoppingbag", response_class=HTMLResponse) def shoppingbag( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: recently = repo.collection(db, cat_id=29, sort_field="bestselling", view_count=4)["products"] return render( request, "cart.html", viewer, db, { "cart": repo.cart_view(db, viewer.owner_key), "recently": recently, "message": request.query_params.get("message"), "error": request.query_params.get("error"), }, ) @app.post("/cart/update") def cart_update( item_id: int = Form(...), qty: int = Form(...), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> RedirectResponse: ok = repo.update_qty(db, viewer.owner_key, item_id, qty) db.commit() target = "/shoppingbag" if ok else "/shoppingbag?error=That+item+is+not+in+your+bag." return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token) @app.post("/cart/remove") def cart_remove( item_id: int = Form(...), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> RedirectResponse: ok = repo.remove_item(db, viewer.owner_key, item_id) db.commit() target = "/shoppingbag" if ok else "/shoppingbag?error=That+item+is+not+in+your+bag." return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token) @app.post("/cart/save") def cart_save( item_id: int = Form(...), saved: int = Form(1), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> RedirectResponse: repo.set_saved(db, viewer.owner_key, item_id, bool(saved)) db.commit() return _set_session_cookie( RedirectResponse("/shoppingbag", status_code=303), viewer.token ) @app.post("/cart/redeem") def cart_redeem( code: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> RedirectResponse: ok, message = repo.redeem(db, viewer.owner_key, code) db.commit() key = "message" if ok else "error" return _set_session_cookie( RedirectResponse(f"/shoppingbag?{key}={message.replace(' ', '+')}", status_code=303), viewer.token, ) # --------------------------------------------------------------------------- # checkout (local sandbox payment profile only) # --------------------------------------------------------------------------- @app.get("/checkout", response_class=HTMLResponse) def checkout( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: cart = repo.cart_view(db, viewer.owner_key) return render( request, "checkout.html", viewer, db, { "cart": cart, "addresses": repo.addresses(db, viewer.owner) if viewer.signed_in else [], "error": request.query_params.get("error"), }, ) @app.post("/checkout") def place_order( request: Request, last_name: str = Form(""), postal: str = Form(""), scenario: str = Form("approved"), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: cart = repo.cart_view(db, viewer.owner_key) if cart["empty"]: return _set_session_cookie( RedirectResponse("/shoppingbag", status_code=303), viewer.token ) if not last_name.strip() or not postal.strip(): return _set_session_cookie( RedirectResponse( "/checkout?error=Enter+a+last+name+and+a+billing+postal+code.", status_code=303, ), viewer.token, ) if scenario == "declined": return _set_session_cookie( RedirectResponse( "/checkout?error=Your+payment+was+declined.+Try+another+method.", status_code=303, ), viewer.token, ) order = repo.place_order( db, viewer.owner_key, owner=viewer.owner, last_name=last_name.strip(), postal=postal.strip(), payment_ref=f"local-sandbox:{scenario}", ) db.commit() if order is None: return _set_session_cookie( RedirectResponse("/shoppingbag", status_code=303), viewer.token ) return _set_session_cookie( RedirectResponse(f"/purchase/order/{order['order_id']}", status_code=303), viewer.token, ) # --------------------------------------------------------------------------- # account and orders # --------------------------------------------------------------------------- ACCOUNT_NAV = [ ("My Account", "/account"), ("My Rewards", "/account/myrewards"), ("Purchase History & Order Tracking", "/purchase/history"), ("Payment Methods", "/account/paymentmethods"), ("Saved Addresses", "/account/addresses"), ("Change Email Settings", "/account/email/settings?action=emailPrefs"), ("Change Email Address", "/account/email"), ("Change Password", "/account/password"), ("Change Catalog Settings", "/account/catalog"), ("Wish List", "/webapp/wcs/stores/servlet/WishListDisplay"), ] def _merge_guest_bag(db: sqlite3.Connection, guest_key: str, member_key: str) -> None: """Carry an anonymous shopping bag into the member's bag on sign-in.""" if guest_key == member_key: return guest = db.execute( "SELECT cart_id FROM carts WHERE owner_key = ?", (guest_key,) ).fetchone() if guest is None: return member = repo.get_or_create_cart(db, member_key) db.execute( "UPDATE cart_items SET cart_id = ? WHERE cart_id = ?", (member["cart_id"], guest["cart_id"]), ) db.execute("DELETE FROM cart_promotions WHERE cart_id = ?", (guest["cart_id"],)) db.execute("DELETE FROM carts WHERE cart_id = ?", (guest["cart_id"],)) def _require_member(request: Request, viewer: Viewer, db: sqlite3.Connection): if viewer.signed_in: return None return render( request, "signin_required.html", viewer, db, {"account_nav": ACCOUNT_NAV, "next": request.url.path}, status_code=200, ) @app.get("/webapp/wcs/stores/servlet/LogonForm", response_class=HTMLResponse) def logon_form( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render( request, "signin.html", viewer, db, { "error": request.query_params.get("error"), "demo_email": DEMO_EMAIL, "demo_password": DEMO_PASSWORD, }, ) @app.post("/webapp/wcs/stores/servlet/LogonForm") def logon( request: Request, email: str = Form(""), password: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: try: result = auth.sign_in(viewer.token, email=email.strip(), password=password) # sign_in rotates the session token; carry the new one on the cookie. rotated = result.get("session_token") or viewer.token guest_key = viewer.owner_key signed_in = Viewer(rotated, auth.resolve_session(rotated)) _merge_guest_bag(db, guest_key, signed_in.owner_key) db.commit() return _set_session_cookie( RedirectResponse("/account", status_code=303), rotated ) except Exception: return render( request, "signin.html", viewer, db, { "error": "We could not sign you in with that email and password.", "demo_email": DEMO_EMAIL, "demo_password": DEMO_PASSWORD, }, status_code=200, ) @app.post("/account/signout") def signout(viewer: Viewer = Depends(get_viewer)) -> RedirectResponse: try: auth.sign_out(viewer.token) except Exception: pass response = RedirectResponse("/", status_code=303) response.delete_cookie(SESSION_COOKIE, path="/") return response @app.get("/account", response_class=HTMLResponse) def account_home( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "account.html", viewer, db, { "account_nav": ACCOUNT_NAV, "orders": repo.orders_for(db, viewer.owner)[:3], "addresses": repo.addresses(db, viewer.owner), }, ) @app.get("/account/myrewards", response_class=HTMLResponse) def account_rewards( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate orders = repo.orders_for(db, viewer.owner) spent = sum(o["total"] for o in orders) return render( request, "rewards.html", viewer, db, { "account_nav": ACCOUNT_NAV, "points": int(spent * 10), "spent": round(spent, 2), "orders": orders, }, ) @app.get("/account/paymentmethods", response_class=HTMLResponse) def account_payment( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "payment_methods.html", viewer, db, {"account_nav": ACCOUNT_NAV} ) @app.get("/account/addresses", response_class=HTMLResponse) def account_addresses( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "addresses.html", viewer, db, { "account_nav": ACCOUNT_NAV, "addresses": repo.addresses(db, viewer.owner), "errors": request.query_params.getlist("missing"), "message": request.query_params.get("message"), }, ) @app.post("/account/addresses") def add_address( request: Request, first_name: str = Form(""), last_name: str = Form(""), street1: str = Form(""), street2: str = Form(""), city: str = Form(""), state: str = Form(""), postal: str = Form(""), phone: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: gate = _require_member(request, viewer, db) if gate: return gate missing = repo.add_address( db, viewer.owner, { "first_name": first_name, "last_name": last_name, "street1": street1, "street2": street2, "city": city, "state": state, "postal": postal, "phone": phone, }, ) db.commit() if missing: query = "&".join(f"missing={field}" for field in missing) return _set_session_cookie( RedirectResponse(f"/account/addresses?{query}", status_code=303), viewer.token ) return _set_session_cookie( RedirectResponse("/account/addresses?message=Address+saved.", status_code=303), viewer.token, ) @app.post("/account/addresses/delete") def remove_address( request: Request, address_id: int = Form(...), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: gate = _require_member(request, viewer, db) if gate: return gate ok = repo.delete_address(db, viewer.owner, address_id) db.commit() message = "Address removed." if ok else "That address is not on your account." return _set_session_cookie( RedirectResponse( f"/account/addresses?message={message.replace(' ', '+')}", status_code=303 ), viewer.token, ) @app.get("/account/email", response_class=HTMLResponse) def account_email( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "change_email.html", viewer, db, {"account_nav": ACCOUNT_NAV, "message": request.query_params.get("message")}, ) @app.get("/account/email/settings", response_class=HTMLResponse) def account_email_settings( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "email_settings.html", viewer, db, { "account_nav": ACCOUNT_NAV, "prefs": repo.email_prefs(db, viewer.owner), "message": request.query_params.get("message"), }, ) @app.post("/account/email/settings") def save_email_settings( request: Request, subscribed: str = Form(""), frequency: str = Form("weekly"), catalog_opt: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: gate = _require_member(request, viewer, db) if gate: return gate repo.set_email_prefs( db, viewer.owner, subscribed=bool(subscribed), frequency=frequency, catalog_opt=bool(catalog_opt), ) db.commit() return _set_session_cookie( RedirectResponse( "/account/email/settings?action=emailPrefs&message=Email+settings+saved.", status_code=303, ), viewer.token, ) @app.get("/account/password", response_class=HTMLResponse) def account_password( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "change_password.html", viewer, db, { "account_nav": ACCOUNT_NAV, "error": request.query_params.get("error"), "message": request.query_params.get("message"), }, ) @app.post("/account/password") def change_password( request: Request, new_password: str = Form(""), confirm_password: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: gate = _require_member(request, viewer, db) if gate: return gate if len(new_password) < 8: target = "/account/password?error=Use+at+least+8+characters." elif new_password != confirm_password: target = "/account/password?error=Those+passwords+do+not+match." else: target = "/account/password?message=Password+updated." return _set_session_cookie(RedirectResponse(target, status_code=303), viewer.token) @app.get("/account/catalog", response_class=HTMLResponse) def account_catalog( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "catalog_settings.html", viewer, db, {"account_nav": ACCOUNT_NAV, "prefs": repo.email_prefs(db, viewer.owner)}, ) @app.get("/purchase/history", response_class=HTMLResponse) def purchase_history( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render( request, "purchase_history.html", viewer, db, { "account_nav": ACCOUNT_NAV, "orders": repo.orders_for(db, viewer.owner) if viewer.signed_in else [], "stores": repo.find_stores(db, ""), "lookup_error": request.query_params.get("error"), }, ) @app.post("/purchase/history") def order_lookup( request: Request, orderId: str = Form(""), lastName: str = Form(""), postalCd: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: found = repo.lookup_order( db, order_number=orderId, last_name=lastName, postal=postalCd ) if found: return _set_session_cookie( RedirectResponse(f"/purchase/order/{found['order_id']}", status_code=303), viewer.token, ) return render( request, "purchase_history.html", viewer, db, { "account_nav": ACCOUNT_NAV, "orders": repo.orders_for(db, viewer.owner) if viewer.signed_in else [], "stores": repo.find_stores(db, ""), "lookup_error": "We could not find an order with those details.", }, ) @app.get("/purchase/order/{order_id}", response_class=HTMLResponse) def order_page( request: Request, order_id: str, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: order = repo.order_detail(db, order_id) if order is None: return render(request, "not_found.html", viewer, db, {}, status_code=404) if order["owner"] != viewer.owner: return render( request, "signin_required.html", viewer, db, {"account_nav": ACCOUNT_NAV, "next": request.url.path}, status_code=403, ) return render( request, "order.html", viewer, db, {"order": order, "account_nav": ACCOUNT_NAV} ) @app.get("/webapp/wcs/stores/servlet/WishListDisplay", response_class=HTMLResponse) def wishlist_page( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: gate = _require_member(request, viewer, db) if gate: return gate return render( request, "wishlist.html", viewer, db, {"account_nav": ACCOUNT_NAV, "items": repo.wishlist(db, viewer.owner)}, ) @app.post("/wishlist/toggle") def wishlist_toggle( request: Request, product_id: str = Form(...), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> Any: if not viewer.signed_in: return _set_session_cookie( RedirectResponse( "/webapp/wcs/stores/servlet/LogonForm", status_code=303 ), viewer.token, ) repo.toggle_wishlist(db, viewer.owner, product_id) db.commit() return _set_session_cookie( RedirectResponse(f"/llb/shop/{product_id}", status_code=303), viewer.token ) # --------------------------------------------------------------------------- # service pages # --------------------------------------------------------------------------- def _stores_page( request: Request, db: sqlite3.Connection, viewer: Viewer, term: str ) -> HTMLResponse: return render( request, "stores.html", viewer, db, { "stores": repo.find_stores(db, term), "term": term, "searched": bool(term), "store_finder_id": STORE_FINDER_ID, }, ) @app.get("/giftcard/lookup", response_class=HTMLResponse) def giftcard_lookup( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render( request, "giftcard.html", viewer, db, { "balance": None, "error": request.query_params.get("error"), "demo_code": "6006000000000001", }, ) @app.post("/giftcard/lookup", response_class=HTMLResponse) def giftcard_check( request: Request, code: str = Form(""), pin: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: card = repo.gift_card_balance(db, code, pin) return render( request, "giftcard.html", viewer, db, { "balance": card["balance"] if card else None, "error": None if card else "We could not find that gift card number and PIN.", "demo_code": "6006000000000001", }, ) @app.get("/catalog/request", response_class=HTMLResponse) def catalog_request_page( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render( request, "catalog_request.html", viewer, db, {"errors": request.query_params.getlist("missing"), "submitted": False}, ) @app.post("/catalog/request", response_class=HTMLResponse) def catalog_request_submit( request: Request, first_name: str = Form(""), last_name: str = Form(""), email: str = Form(""), street1: str = Form(""), city: str = Form(""), state: str = Form(""), postal: str = Form(""), db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: missing = repo.request_catalog( db, { "first_name": first_name, "last_name": last_name, "email": email, "street1": street1, "city": city, "state": state, "postal": postal, }, ) db.commit() return render( request, "catalog_request.html", viewer, db, {"errors": missing, "submitted": not missing}, ) @app.get("/freeshipping/", response_class=HTMLResponse) def free_shipping( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render(request, "free_shipping.html", viewer, db, {}) @app.get("/buy/pt/index", response_class=HTMLResponse) def collections_index( request: Request, db: sqlite3.Connection = Depends(get_db), viewer: Viewer = Depends(get_viewer), ) -> HTMLResponse: return render( request, "collections.html", viewer, db, {"tree": repo.category_tree(db)}, ) # A form action reached with GET (a typed URL, a refresh after back) should # land the visitor back on the surface that owns the form rather than 405. # These are redirect-only: no GET request mutates anything. _POST_ONLY_REDIRECTS = { "/cart/add": "/shoppingbag", "/cart/update": "/shoppingbag", "/cart/remove": "/shoppingbag", "/cart/save": "/shoppingbag", "/cart/redeem": "/shoppingbag", "/wishlist/toggle": "/webapp/wcs/stores/servlet/WishListDisplay", "/account/addresses/delete": "/account/addresses", "/account/signout": "/", } def _register_get_redirects() -> None: for source, target in _POST_ONLY_REDIRECTS.items(): def _redirect(destination: str = target) -> RedirectResponse: return RedirectResponse(destination, status_code=303) app.add_api_route( source, _redirect, methods=["GET"], include_in_schema=False ) _register_get_redirects() @app.exception_handler(404) async def not_found(request: Request, exc: Any) -> HTMLResponse: # noqa: ARG001 with db_session() as connection: viewer = get_viewer(request) return render(request, "not_found.html", viewer, connection, {}, status_code=404)