| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import binascii |
| import hashlib |
| import hmac |
| import ipaddress |
| import json |
| import mimetypes |
| import os |
| import re |
| import secrets |
| import signal |
| import sys |
| import threading |
| from dataclasses import replace |
| from http.cookies import SimpleCookie |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| from pathlib import Path |
| from typing import Any, Mapping |
| from urllib.parse import parse_qs, parse_qsl, unquote, urlencode, urlsplit |
|
|
| import auth_views |
| import render as views |
| import specialty_store as specialty |
| import specialty_views |
| import wishlist_store as wishlist |
| import wishlist_views |
| from browse_breadth import load_browse_breadth |
| from deals_catalog import build_deals_view, load_deals_catalog |
| from external_verification import ( |
| ExternalRegistrationVerification, |
| VerificationConfigurationError, |
| VerificationRateLimited, |
| VerificationUnavailable, |
| load_external_registration_verification, |
| registration_frontend_script, |
| ) |
| from home_catalog import load_home_product_catalog |
| from home_category_catalog import load_home_category_groups, load_home_category_offers |
| from mail_transport import ( |
| SMTPConfig, |
| load_local_inbox_url, |
| load_smtp_config, |
| send_smtp_message, |
| smtp_error_summary, |
| smtp_public_summary, |
| ) |
| from product_options import UNAVAILABLE_SELECTION_COPY |
| from review_catalog import render_reviews_section |
| from review_store import ( |
| ReviewAuthenticationRequired, |
| ReviewNotFound, |
| ReviewPermissionDenied, |
| ReviewValidationError, |
| ) |
| from search_catalog import ( |
| SearchRequest, |
| SearchValidationError, |
| build_search_hit, |
| candidate_search_hits, |
| is_portable_ssd_contract_query, |
| normalize_search_query, |
| parse_search_request, |
| refine_search_hits, |
| source_department_for_query, |
| ) |
| from search_suggestions import ( |
| SearchSuggestionValidationError, |
| build_suggestion_corpus, |
| parse_suggestion_request, |
| suggest_search_terms, |
| ) |
| from stripe_gateway import ( |
| PAYMENT_MODE_STRIPE_TEST, |
| STRIPE_PROVIDER_SESSION_PATTERN, |
| STRIPE_WEBHOOK_MAX_BYTES, |
| STRIPE_WEBHOOK_PATH, |
| PaymentConfig, |
| StripeAPIError, |
| StripeConfigurationError, |
| StripeGateway, |
| StripeSignatureError, |
| load_payment_config, |
| verify_stripe_signature, |
| ) |
| from store import ( |
| AddressInUse, |
| AddressNotFound, |
| AddressRevisionConflict, |
| BEST_SELLERS_PATH, |
| CART_LINE_ID_PATTERN, |
| COMPARE_LINE_ID_PATTERN, |
| MAIL_LOCAL_ONLY, |
| MAIL_SMTP_PENDING, |
| PDP_PATH, |
| SUPPORTED_DELIVERY_COUNTRIES, |
| SUPPORTED_DELIVERY_COUNTRY_CODES, |
| TARGET_ASIN, |
| TERMINAL_PATHS, |
| CheckoutReconciliationRequired, |
| ContractError, |
| OrderActionTokenInvalid, |
| OrderNotFound, |
| OrderStateConflict, |
| ReturnNotFound, |
| Store, |
| normalize_email, |
| ) |
|
|
|
|
| ROOT = Path(__file__).resolve().parent |
| STATIC_ROOT = (ROOT / "static").resolve() |
| FIXTURE_ROOT = (ROOT / "fixtures").resolve() |
| SCHEMA_PATH = ROOT / "schema.sql" |
| DEFAULT_DB = ROOT / "runtime" / "websitebench" / "amazon.sqlite3" |
| SESSION_COOKIE = "__Host-websitebench-amazon-session" |
| FLOW_COOKIE = "amazon_clone_flow" |
| SESSION_BYTES = 32 |
| TRUE_ENV_VALUES = frozenset({"1", "true", "yes", "on"}) |
| |
| |
| |
| MAX_FORM_BYTES = 128 * 1024 |
| MAX_ADMIN_BYTES = 64 * 1024 |
| MAX_AUTH_JSON_BYTES = 4 * 1024 |
| PDP_ROUTE = re.compile(r"^/([^/]+)/dp/([A-Z0-9]{10})$") |
| BARE_PDP_ROUTE = re.compile(r"^/dp/([A-Z0-9]{10})$") |
| HOME_COLLECTION_ROUTE = re.compile( |
| r"^/gp/home-collection/([a-z0-9-]+)(?:/([1-4]))?$" |
| ) |
| PRODUCT_REVIEWS_ROUTE = re.compile(r"^/product-reviews/([A-Z0-9]{10})$") |
| PRODUCT_REVIEW_HELPFUL_ROUTE = re.compile( |
| r"^/product-reviews/([A-Z0-9]{10})/helpful$" |
| ) |
| HOME_PRODUCT_CATALOG = load_home_product_catalog(FIXTURE_ROOT) |
| SEARCH_SUGGESTION_CORPUS = build_suggestion_corpus(HOME_PRODUCT_CATALOG) |
| BROWSE_BREADTH = load_browse_breadth(FIXTURE_ROOT) |
| SEARCH_DEPARTMENT_SUPPLEMENTS = ( |
| *BROWSE_BREADTH["department_commerce_supplements"], |
| *BROWSE_BREADTH["search_commerce_cards"], |
| ) |
| SEARCH_COMMERCE_PRODUCT_CATALOG = { |
| str(product["asin"]): product |
| for product in BROWSE_BREADTH["search_commerce_cards"] |
| } |
| FROZEN_SEARCH_QUERIES = frozenset( |
| normalize_search_query(str(query)) |
| for product in BROWSE_BREADTH["search_commerce_cards"] |
| for query in product.get("captured_queries", ()) |
| if isinstance(query, str) and query.strip() |
| ) |
| HOME_CATEGORY_PRODUCT_CATALOG = { |
| str(product["asin"]): product |
| for product in load_home_category_offers(FIXTURE_ROOT) |
| } |
| HOME_CATEGORY_GROUPS = load_home_category_groups(FIXTURE_ROOT) |
| HOME_CATEGORY_QUERY_TILES: dict[str, dict[str, Any]] = {} |
| for _home_category_group in HOME_CATEGORY_GROUPS.values(): |
| HOME_CATEGORY_QUERY_TILES[ |
| normalize_search_query(str(_home_category_group["title"])) |
| ] = { |
| "collection_key": str(_home_category_group["key"]), |
| "tile_index": None, |
| "products": tuple( |
| dict(product) |
| for tile in _home_category_group["tiles"] |
| for product in tile["products"] |
| ), |
| } |
| for _home_category_tile in _home_category_group["tiles"]: |
| HOME_CATEGORY_QUERY_TILES[ |
| normalize_search_query(str(_home_category_tile["query"])) |
| ] = { |
| "collection_key": str(_home_category_group["key"]), |
| "tile_index": int(_home_category_tile["index"]), |
| "products": tuple( |
| dict(product) for product in _home_category_tile["products"] |
| ), |
| } |
| PORTABLE_SEARCH_ORDER = ( |
| "B08HN37XC1", |
| "B08GTYFC37", |
| "B0F6NKYDTY", |
| "B0BGKXX9TK", |
| "B0874XN4D8", |
| "B0C5JQ68FY", |
| "B08GV9M64L", |
| "B09VLK9W3S", |
| "B0CHFSWM2P", |
| ) |
| DEALS_CATALOG = load_deals_catalog( |
| FIXTURE_ROOT, BROWSE_BREADTH["verified_offers"] |
| ) |
| DEALS_PRODUCT_CATALOG = { |
| str(product["asin"]): product for product in DEALS_CATALOG |
| } |
| AUTH_PATHS = frozenset({"/ap/signin", "/ap/register", "/ap/forgotpassword", "/ap/cvf/verify"}) |
| AUTH_SIGNOUT_PATH = "/ap/signout" |
| AUTH_SEND_CODE_PATH = "/api/auth/send-code" |
| AUTH_VERIFY_CODE_PATH = "/api/auth/verify-code" |
| EXTERNAL_AUTH_API_PATHS = frozenset( |
| {AUTH_SEND_CODE_PATH, AUTH_VERIFY_CODE_PATH} |
| ) |
| ADDRESS_BOOK_PATH = "/a/addresses" |
| ADDRESS_ADD_PATH = "/a/addresses/add" |
| ADDRESS_EDIT_PATH = "/a/addresses/edit" |
| ADDRESS_CREATE_PATH = "/a/addresses/create" |
| ADDRESS_UPDATE_PATH = "/a/addresses/update" |
| ADDRESS_DELETE_PATH = "/a/addresses/delete" |
| ADDRESS_DEFAULT_PATH = "/a/addresses/set-default" |
| ADDRESS_BOOK_POST_PATHS = frozenset( |
| { |
| ADDRESS_CREATE_PATH, |
| ADDRESS_UPDATE_PATH, |
| ADDRESS_DELETE_PATH, |
| ADDRESS_DEFAULT_PATH, |
| } |
| ) |
| ADDRESS_FORM_NAMES = frozenset( |
| { |
| "fullName", |
| "addressLine1", |
| "addressLine2", |
| "city", |
| "state", |
| "postalCode", |
| "countryCode", |
| "phoneNumber", |
| } |
| ) |
| CART_MUTATION_PATHS = frozenset( |
| { |
| "/gp/buy/now", |
| "/gp/cart/add.html", |
| "/gp/cart/update.html", |
| "/gp/cart/delete.html", |
| "/gp/cart/save-for-later.html", |
| "/gp/cart/move-to-cart.html", |
| } |
| ) |
| |
| |
| |
| AUTHENTICATED_CART_MUTATION_PATHS = frozenset( |
| CART_MUTATION_PATHS - {"/gp/buy/now"} |
| ) |
| BUY_NOW_PATH = "/gp/buy/now" |
| ADD_TO_CART_CONFIRMATION_PATH = "/gp/cart/added" |
| BUY_NOW_CONTINUE_PATH = "/gp/buy/now/continue" |
| CHECKOUT_START_PATH = "/gp/buy/spc/handlers/display.html" |
| CHECKOUT_ADDRESS_PATH = "/gp/buy/addressselect/handlers/display.html" |
| CHECKOUT_DELIVERY_PATH = "/gp/buy/shipoptionselect/handlers/display.html" |
| CHECKOUT_PAYMENT_PATH = "/gp/buy/payselect/handlers/display.html" |
| PLACE_ORDER_PATH = "/gp/buy/place-order" |
| STRIPE_CHECKOUT_PATH = "/gp/buy/stripe-checkout" |
| STRIPE_RETURN_PATH = "/gp/buy/stripe-return" |
| STRIPE_CANCEL_PATH = "/gp/buy/stripe-cancel" |
| ORDER_DETAIL_PATH = "/gp/your-account/order-details" |
| ORDER_EMAIL_RETRY_PATH = "/gp/your-account/order-email/retry" |
| ORDER_CANCEL_PATH = "/gp/your-account/order-cancel" |
| RETURN_CREATE_PATH = "/gp/your-account/returns/create" |
| RETURN_DETAIL_PATH = "/gp/your-account/returns/details" |
| COMPARE_PATH = "/gp/compare" |
| COMPARE_MUTATION_PATHS = frozenset( |
| {"/gp/compare/add", "/gp/compare/remove", "/gp/compare/clear"} |
| ) |
| CHECKOUT_STAGE_ORDER = { |
| "CART_READY": 0, |
| "ADDRESS_SELECTED": 1, |
| "DELIVERY_SELECTED": 2, |
| "PAYMENT_SELECTED": 3, |
| "PAYMENT_PENDING": 3, |
| "PLACED": 4, |
| } |
| ASIN_PATTERN = re.compile(r"^[A-Z0-9]{10}$") |
| PROTECTED_ACCOUNT_PATHS = frozenset( |
| {"/gp/css/homepage.html", "/gp/css/order-history"} |
| ) |
| WISHLIST_POST_PATHS = frozenset( |
| { |
| wishlist_views.WISHLIST_CREATE_PATH, |
| wishlist_views.WISHLIST_RENAME_PATH, |
| wishlist_views.WISHLIST_DELETE_PATH, |
| wishlist_views.WISHLIST_ADD_ITEM_PATH, |
| wishlist_views.WISHLIST_REMOVE_ITEM_PATH, |
| wishlist_views.WISHLIST_MOVE_TO_CART_PATH, |
| } |
| ) |
| WISHLIST_FRIENDS_PATH = "/hz/wishlist/your-friends" |
| SITE_DIRECTORY_PATH = "/gp/site-directory" |
| DELIVERY_PREFERENCE_PATH = "/gp/delivery/ajax/address-change.html" |
| DELIVERY_SELECTIONS_PATH = "/gp/delivery/ajax/address-selections" |
| SEARCH_SUGGESTIONS_PATH = "/search/suggestions" |
| LANGUAGE_PREFERENCE_PATH = "/customer-preferences/edit" |
| CUSTOMER_SERVICE_PATH = "/gp/help/customer/display.html" |
| CUSTOMER_SERVICE_NODE = "508510" |
| SHIPPING_POLICIES_NODE = "468520" |
| RETURNS_REPLACEMENTS_NODE = "201819200" |
| CONDITIONS_OF_USE_NODE = "508088" |
| PRIVACY_NOTICE_NODE = "468496" |
| GIFT_CARDS_PATH = specialty.GIFT_CARDS_PATH |
| SPECIALTY_POST_PATHS = frozenset( |
| { |
| specialty.GIFT_CARD_PREVIEW_PATH, |
| specialty.GIFT_CARD_REDEEM_PATH, |
| specialty.SELL_DRAFT_PATH, |
| specialty.REGISTRY_CREATE_PATH, |
| } |
| ) |
|
|
|
|
| def env_flag(name: str) -> bool: |
| return os.environ.get(name, "").strip().casefold() in TRUE_ENV_VALUES |
|
|
|
|
| def cloudflare_review_profile() -> bool: |
| profile = os.environ.get("WEBSITEBENCH_BACKEND_PROFILE") |
| if profile is None: |
| |
| profile = os.environ.get("CLAWBENCH_BACKEND_PROFILE", "") |
| return profile.strip() == "cloudflare-review" |
|
|
|
|
| def browser_cookie(name: str, value: str, *, max_age: int | None = None) -> str: |
| attributes = [f"{name}={value}", "Path=/", "HttpOnly", "SameSite=Lax"] |
| if ( |
| name == SESSION_COOKIE |
| or env_flag("AMAZON_COOKIE_SECURE") |
| or cloudflare_review_profile() |
| ): |
| attributes.append("Secure") |
| if max_age is not None: |
| attributes.append(f"Max-Age={max_age}") |
| return "; ".join(attributes) |
|
|
|
|
| def public_basic_auth_credentials() -> tuple[str, str] | None: |
| username = os.environ.get("AMAZON_BASIC_AUTH_USERNAME", "") |
| password = os.environ.get("AMAZON_BASIC_AUTH_PASSWORD", "") |
| if not username and not password: |
| return None |
| if not username or not password: |
| raise ValueError( |
| "AMAZON_BASIC_AUTH_USERNAME and AMAZON_BASIC_AUTH_PASSWORD " |
| "must be configured together" |
| ) |
| return username, password |
| PUBLIC_NAVIGATION_LANDINGS: dict[ |
| str, tuple[str, str, tuple[tuple[str, str], ...]] |
| ] = { |
| LANGUAGE_PREFERENCE_PATH: ( |
| "Language preferences", |
| "This local snapshot is available in English (United States). Continue browsing or visit customer service.", |
| ( |
| ("Continue in English", "/"), |
| ("Browse books", "/s?k=books"), |
| ("Visit Customer Service", "/gp/help/customer/display.html?nodeId=508510"), |
| ), |
| ), |
| "/gp/navigation/amazon-business": ( |
| "Amazon Business", |
| "Business accounts are a separate registration programme and are not modelled by this storefront. A personal account can be created from the sign-in page and used for the whole shopping journey.", |
| ( |
| ("Create an account", "/ap/register"), |
| ("Sign in", "/ap/signin"), |
| ("Return to Amazon home", "/"), |
| ), |
| ), |
| "/gp/navigation/amazon-music": ( |
| "Amazon Music", |
| "Browse music-related picks available in this offline storefront.", |
| (("Browse featured products", "/s?k=music"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/kindle": ( |
| "Kindle E-readers & Books", |
| "Browse the captured Books department and reading-related products.", |
| (("Browse Books", "/s?i=books"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/appstore": ( |
| "Amazon Appstore", |
| "App downloads are outside this offline shopping clone.", |
| (("Browse Computers", "/s?i=computers"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/automotive": ( |
| "Automotive", |
| "Browse products in the local catalog while the Automotive department remains an offline boundary.", |
| (("Browse all products", "/s?k=products"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/baby": ( |
| "Baby", |
| "Browse products in the local catalog while the Baby department remains an offline boundary.", |
| (("Browse Home & Kitchen", "/s?i=home-kitchen"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/shop-by-interest": ( |
| "Shop By Interest", |
| "Continue into the captured Amazon shopping departments.", |
| (("Browse Today's Deals", "/gp/goldbox/"), ("Browse all departments", "/gp/site-directory")), |
| ), |
| "/gp/navigation/amazon-live": ( |
| "Amazon Live", |
| "Live video streams are outside this offline shopping clone.", |
| (("Browse Today's Deals", "/gp/goldbox/"), ("Return to Amazon home", "/")), |
| ), |
| "/gp/navigation/international-shopping": ( |
| "International Shopping", |
| "The local storefront is showing USD offers for delivery to Singapore.", |
| (("Browse all products", "/s?k=products"), ("Choose delivery location", DELIVERY_PREFERENCE_PATH)), |
| ), |
| "/gp/navigation/second-chance": ( |
| "Amazon Second Chance", |
| "Refurbishment services are outside this offline shopping clone.", |
| (("Browse Today's Deals", "/gp/goldbox/"), ("Return to Amazon home", "/")), |
| ), |
| } |
|
|
| |
| |
| |
| _BOUNDARY_LANDINGS: tuple[tuple[str, str, str], ...] = ( |
| ("careers", "Careers", "Recruitment is outside this shopping storefront."), |
| ("blog", "About Amazon Blog", "Editorial content is outside this shopping storefront."), |
| ("about", "About Amazon", "Corporate information is outside this shopping storefront."), |
| ("investor-relations", "Investor Relations", "Investor material is outside this shopping storefront."), |
| ("amazon-science", "Amazon Science", "Research publications are outside this shopping storefront."), |
| ("amazon-devices", "Amazon Devices", "This storefront's captured catalog stocks no Amazon-branded devices, so there is no local department to browse."), |
| ("sell-business", "Sell on Amazon Business", "Seller registration is outside this shopping storefront."), |
| ("sell-apps", "Sell apps on Amazon", "Developer programmes are outside this shopping storefront."), |
| ("affiliate", "Become an Affiliate", "The affiliate programme is outside this shopping storefront."), |
| ("advertise", "Advertise Your Products", "Advertising services are outside this shopping storefront."), |
| ("self-publish", "Self-Publish with Us", "Publishing services are outside this shopping storefront."), |
| ("amazon-hub", "Host an Amazon Hub", "Pickup-location hosting is outside this shopping storefront."), |
| ("business-card", "Amazon Business Card", "Credit products are outside this shopping storefront. Checkout here uses a local sandbox gateway and charges nothing."), |
| ("shop-with-points", "Shop with Points", "Rewards-point redemption is not modelled by this storefront."), |
| ("reload-balance", "Reload Your Balance", "Gift-card balance reloads are not modelled by this storefront."), |
| ("currency-converter", "Amazon Currency Converter", "This storefront prices every offer in USD and does not convert currencies."), |
| ("covid-19", "Amazon and COVID-19", "This announcement page is outside this shopping storefront."), |
| ("content-and-devices", "Manage Your Content and Devices", "Digital content libraries are outside this shopping storefront."), |
| ("recalls", "Recalls and Product Safety Alerts", "Safety notices are outside this shopping storefront."), |
| ("health-data-privacy", "Consumer Health Data Privacy Disclosure", "This storefront collects no health data. The Privacy Notice lists everything it does store."), |
| ("ads-privacy", "Your Ads Privacy Choices", "This storefront runs no advertising, sets no advertising cookies, and makes no third-party requests."), |
| ("new-releases", "New Releases", "This storefront freezes one Best Sellers ranking. New Releases is not modelled."), |
| ("internal-hard-drives", "Internal Hard Drives", "This storefront's captured catalog does not stock Internal Hard Drives. The frozen Best Sellers ranking covers external solid state drives."), |
| ("usb-flash-drives", "USB Flash Drives", "This storefront's captured catalog does not stock USB Flash Drives. The frozen Best Sellers ranking covers external solid state drives."), |
| ("network-attached-storage", "Network Attached Storage", "This storefront's captured catalog does not stock Network Attached Storage. The frozen Best Sellers ranking covers external solid state drives."), |
| ("internal-solid-state-drives", "Internal Solid State Drives", "This storefront's captured catalog does not stock Internal Solid State Drives. The frozen Best Sellers ranking covers external solid state drives."), |
| ("tape-libraries", "Tape Libraries", "This storefront's captured catalog does not stock Tape Libraries. The frozen Best Sellers ranking covers external solid state drives."), |
| ("tape-drives", "Floppy & Tape Drives", "This storefront's captured catalog does not stock Floppy & Tape Drives. The frozen Best Sellers ranking covers external solid state drives."), |
| ("external-zip-drives", "External Zip Drives", "This storefront's captured catalog does not stock External Zip Drives. The frozen Best Sellers ranking covers external solid state drives."), |
| ("crypto-hardware-wallets", "Crypto Hardware Wallets", "This storefront's captured catalog does not stock Crypto Hardware Wallets. The frozen Best Sellers ranking covers external solid state drives."), |
| ("movers-shakers", "Movers & Shakers", "This storefront freezes one Best Sellers ranking. Movers & Shakers is not modelled."), |
| ) |
|
|
| |
| _BRAND_LANDINGS: tuple[tuple[str, str], ...] = ( |
| ("amazon-music", "Amazon Music"), ("amazon-ads", "Amazon Ads"), ("6pm", "6pm"), |
| ("abebooks", "AbeBooks"), ("acx", "ACX"), ("veeqo", "Veeqo"), |
| ("amazonglobal", "AmazonGlobal"), ("aws", "Amazon Web Services"), |
| ("audible", "Audible"), ("box-office-mojo", "Box Office Mojo"), |
| ("goodreads", "Goodreads"), ("imdb", "IMDb"), ("imdbpro", "IMDbPro"), |
| ("kindle-direct-publishing", "Kindle Direct Publishing"), |
| ("prime-video-direct", "Prime Video Direct"), ("shopbop", "Shopbop"), |
| ("woot", "Woot!"), ("zappos", "Zappos"), ("ring", "Ring"), |
| ("eero", "eero WiFi"), ("blink", "Blink"), |
| ("neighbors-app", "Neighbors App"), ("pillpack", "PillPack"), |
| ) |
|
|
| _BOUNDARY_ACTIONS = ( |
| ("Return to Amazon home", "/"), |
| ("Browse all departments", "/gp/site-directory"), |
| ("Visit Customer Service", "/gp/help/customer/display.html?nodeId=508510"), |
| ) |
|
|
| for _slug, _title, _copy in _BOUNDARY_LANDINGS: |
| PUBLIC_NAVIGATION_LANDINGS.setdefault( |
| f"/gp/navigation/{_slug}", (_title, _copy, _BOUNDARY_ACTIONS) |
| ) |
|
|
| for _slug, _name in _BRAND_LANDINGS: |
| PUBLIC_NAVIGATION_LANDINGS.setdefault( |
| f"/gp/navigation/{_slug}", |
| ( |
| _name, |
| f"{_name} is a separate service. This storefront reproduces the " |
| f"Amazon.com shopping journey only, and makes no request to any " |
| f"other site while you browse.", |
| _BOUNDARY_ACTIONS, |
| ), |
| ) |
|
|
|
|
| def digest(value: str) -> str: |
| return hashlib.sha256(value.encode("utf-8")).hexdigest() |
|
|
|
|
| def delivery_location_token(session_digest: str) -> str: |
| """Per-session token for the delivery-location form. |
| |
| The source storefront carries a `glow-validation-token` on the same form. |
| This is a real one: it is derived from the browser session, so a form |
| harvested from one session cannot be replayed against another. It is |
| checked in addition to, not instead of, the same-origin POST check every |
| other mutation in this clone performs. |
| """ |
|
|
| return digest(f"delivery-location:{session_digest}")[:32] |
|
|
|
|
| def json_bytes(payload: Any) -> bytes: |
| return json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8") |
|
|
|
|
| def compare_entry_product( |
| store: Store, |
| product: dict[str, Any] | Mapping[str, Any], |
| *, |
| eligible_asins: frozenset[str] | None = None, |
| ) -> dict[str, Any]: |
| """Annotate a rendered product from the server-owned compare registry.""" |
|
|
| rendered = dict(product) |
| asin = str(rendered.get("asin") or "") |
| eligible = asin in ( |
| eligible_asins |
| if eligible_asins is not None |
| else store.compare_eligible_asins() |
| ) |
| rendered["compare_eligible"] = eligible |
| if eligible: |
| rendered["default_selected_options"] = store.default_product_options(asin) |
| return rendered |
|
|
|
|
| def product_for_pdp(store: Store, asin: str) -> dict[str, Any] | None: |
| """Return the unified display record while keeping its offer authoritative.""" |
|
|
| product = store.display_product(asin) |
| return compare_entry_product(store, product) if product is not None else None |
|
|
|
|
| def compare_product_for_view( |
| store: Store, compare_item: dict[str, Any] |
| ) -> dict[str, Any]: |
| """Keep rich presentation while making the resolved line quote authoritative.""" |
|
|
| asin = str(compare_item.get("asin") or "") |
| presentation = product_for_pdp(store, asin) or {} |
| return {**presentation, **compare_item, "compare_eligible": True} |
|
|
|
|
| def review_product_source_scope(store: Store, asin: str) -> str | None: |
| """Return the server-owned product scope that authorizes local reviews.""" |
|
|
| if store.display_product(asin) is None: |
| return None |
| if asin in HOME_PRODUCT_CATALOG: |
| return "home_snapshot" |
| if store.product(asin) is not None: |
| return "catalog_product" |
| if store.commerce_offer(asin) is not None: |
| return "commerce_offer" |
| return None |
|
|
|
|
| def valid_account_email(value: str) -> str | None: |
| normalized = normalize_email(value) |
| if not normalized or len(normalized) > 254 or normalized.count("@") != 1: |
| return None |
| local, domain = normalized.split("@", 1) |
| if not local or not domain or any(character.isspace() or ord(character) < 32 for character in normalized): |
| return None |
| return normalized |
|
|
|
|
| def clean_display_name(value: str) -> str | None: |
| cleaned = " ".join(value.strip().split()) |
| if not cleaned or len(cleaned) > 128 or any(ord(character) < 32 for character in cleaned): |
| return None |
| return cleaned |
|
|
|
|
| def clean_checkout_text( |
| value: str, *, maximum: int, required: bool = True |
| ) -> str | None: |
| cleaned = " ".join(value.strip().split()) |
| if required and not cleaned: |
| return None |
| if len(cleaned) > maximum or any(ord(character) < 32 for character in cleaned): |
| return None |
| return cleaned |
|
|
|
|
| def normalized_address_fields(fields: dict[str, str]) -> dict[str, str] | None: |
| """Map one strict browser address form to the store's canonical fields.""" |
|
|
| if not ADDRESS_FORM_NAMES.issubset(fields): |
| return None |
| address = { |
| "full_name": clean_checkout_text(fields["fullName"], maximum=128), |
| "address_line1": clean_checkout_text( |
| fields["addressLine1"], maximum=200 |
| ), |
| "address_line2": clean_checkout_text( |
| fields["addressLine2"], maximum=200, required=False |
| ), |
| "city": clean_checkout_text(fields["city"], maximum=100), |
| "state_region": clean_checkout_text(fields["state"], maximum=100), |
| "postal_code": clean_checkout_text(fields["postalCode"], maximum=32), |
| "country_code": fields["countryCode"].strip().upper(), |
| "phone": clean_checkout_text( |
| fields["phoneNumber"], maximum=32, required=False |
| ), |
| } |
| if ( |
| any(value is None for value in address.values()) |
| or str(address["country_code"]) not in SUPPORTED_DELIVERY_COUNTRY_CODES |
| ): |
| return None |
| return {name: str(value) for name, value in address.items()} |
|
|
|
|
| def review_query_parameters(query: dict[str, list[str]]) -> tuple[int | None, str]: |
| """Parse the two public review controls without accepting ambiguous values.""" |
|
|
| star_values = query.get("reviewStar", []) |
| sort_values = query.get("reviewSort", []) |
| if len(star_values) > 1 or len(sort_values) > 1: |
| raise ReviewValidationError("review filters must have one value") |
| star: int | None = None |
| if star_values: |
| if re.fullmatch(r"[1-5]", star_values[0]) is None: |
| raise ReviewValidationError("reviewStar must be 1 through 5") |
| star = int(star_values[0]) |
| sort = sort_values[0] if sort_values else "recent" |
| if sort not in {"recent", "helpful"}: |
| raise ReviewValidationError("reviewSort must be recent or helpful") |
| return star, sort |
|
|
|
|
| class ReusableThreadingHTTPServer(ThreadingHTTPServer): |
| allow_reuse_address = True |
| daemon_threads = True |
|
|
| def handle_error(self, request: Any, client_address: Any) -> None: |
| """Do not log tracebacks for ordinary clients closing keep-alive sockets.""" |
|
|
| error = sys.exc_info()[1] |
| if isinstance( |
| error, (BrokenPipeError, ConnectionAbortedError, ConnectionResetError) |
| ): |
| return |
| super().handle_error(request, client_address) |
|
|
|
|
| def dispatch_mail_delivery( |
| store: Store, |
| config: SMTPConfig, |
| delivery: dict[str, Any], |
| ) -> bool: |
| """Atomically claim and asynchronously deliver one durable SMTP job.""" |
|
|
| kind = str(delivery["kind"]) |
| email_id = int(delivery["email_id"]) |
| claim_token = store.claim_mail_delivery(kind, email_id) |
| if claim_token is None: |
| return False |
|
|
| def deliver() -> None: |
| try: |
| send_smtp_message( |
| config, |
| recipient=str(delivery["recipient"]), |
| subject=str(delivery["subject"]), |
| body=str(delivery["body"]), |
| ) |
| except Exception as exc: |
| store.mark_mail_delivery( |
| kind, |
| email_id, |
| claim_token=claim_token, |
| sent=False, |
| error_summary=smtp_error_summary(exc), |
| ) |
| else: |
| store.mark_mail_delivery( |
| kind, |
| email_id, |
| claim_token=claim_token, |
| sent=True, |
| ) |
|
|
| worker = threading.Thread( |
| target=deliver, |
| name=f"amazon-clone-mail-{kind}-{email_id}", |
| daemon=True, |
| ) |
| try: |
| worker.start() |
| except RuntimeError as exc: |
| store.mark_mail_delivery( |
| kind, |
| email_id, |
| claim_token=claim_token, |
| sent=False, |
| error_summary=smtp_error_summary(exc), |
| ) |
| return False |
| return True |
|
|
|
|
| def wishlist_selection_query( |
| query: dict[str, list[str]], |
| ) -> tuple[str, dict[str, str]] | None: |
| """Parse one strict, duplicate-free ASIN plus complete option selection.""" |
|
|
| if not query or len(query) > 16 or "ASIN" not in query: |
| return None |
| fields: dict[str, str] = {} |
| for name, values in query.items(): |
| if len(values) != 1: |
| return None |
| if name != "ASIN" and ( |
| not name.startswith("option.") or not name.removeprefix("option.") |
| ): |
| return None |
| fields[name] = values[0] |
| asin = fields.pop("ASIN", "") |
| if ASIN_PATTERN.fullmatch(asin) is None: |
| return None |
| return asin, { |
| name.removeprefix("option."): value |
| for name, value in fields.items() |
| } |
|
|
|
|
| class PublicHandler(BaseHTTPRequestHandler): |
| protocol_version = "HTTP/1.1" |
| store: Store |
| smtp_config: SMTPConfig | None = None |
| local_inbox_url: str | None = None |
| external_registration_verification: ExternalRegistrationVerification | None = None |
| payment_config = PaymentConfig(mode="local-sandbox") |
| stripe_gateway: StripeGateway | None = None |
| server_version = "AmazonClone/0.1" |
|
|
| def log_message(self, format_string: str, *args: Any) -> None: |
| safe_path = self.path |
| if urlsplit(self.path).path.startswith("/ap/"): |
| safe_path = urlsplit(self.path).path |
| message = format_string % args |
| if safe_path != self.path: |
| message = message.replace(self.path, safe_path) |
| sys.stdout.write( |
| json.dumps( |
| { |
| "stream": "public", |
| "client": self.client_address[0], |
| "method": self.command, |
| "path": safe_path, |
| "message": message, |
| }, |
| ensure_ascii=False, |
| ) |
| + "\n" |
| ) |
| sys.stdout.flush() |
|
|
| def _security_headers(self) -> dict[str, str]: |
| headers = { |
| "Content-Security-Policy": ( |
| "default-src 'self'; img-src 'self' data:; style-src 'self'; " |
| "script-src 'self'; connect-src 'self'; form-action 'self'; " |
| "frame-ancestors 'none'; base-uri 'self'" |
| ), |
| "Referrer-Policy": "strict-origin-when-cross-origin", |
| "X-Content-Type-Options": "nosniff", |
| "X-Frame-Options": "DENY", |
| "Cache-Control": "no-store", |
| } |
| if env_flag("AMAZON_HSTS") or cloudflare_review_profile(): |
| headers["Strict-Transport-Security"] = "max-age=31536000" |
| if env_flag("AMAZON_NOINDEX") or cloudflare_review_profile(): |
| headers["X-Robots-Tag"] = "noindex, nofollow, noarchive" |
| return headers |
|
|
| def _public_basic_auth_is_valid(self) -> bool: |
| try: |
| expected = public_basic_auth_credentials() |
| except ValueError: |
| return False |
| if expected is None: |
| return True |
| header = self.headers.get("Authorization", "") |
| scheme, separator, encoded = header.partition(" ") |
| if not separator or scheme.casefold() != "basic": |
| return False |
| try: |
| decoded = base64.b64decode(encoded, validate=True) |
| except binascii.Error: |
| return False |
| username, separator, password = decoded.partition(b":") |
| if not separator: |
| return False |
| expected_username, expected_password = expected |
| return hmac.compare_digest( |
| username, expected_username.encode("utf-8") |
| ) and hmac.compare_digest( |
| password, expected_password.encode("utf-8") |
| ) |
|
|
| def _require_public_basic_auth(self) -> bool: |
| if self._public_basic_auth_is_valid(): |
| return True |
| self.close_connection = True |
| self._send( |
| 401, |
| b"Authentication required.", |
| content_type="text/plain; charset=utf-8", |
| headers={ |
| "Connection": "close", |
| "WWW-Authenticate": 'Basic realm="WebsiteBench Amazon", charset="UTF-8"', |
| }, |
| ) |
| return False |
|
|
| def _send( |
| self, |
| status: int, |
| body: bytes = b"", |
| *, |
| content_type: str = "text/html; charset=utf-8", |
| headers: dict[str, str] | None = None, |
| cookies: list[str] | None = None, |
| ) -> None: |
| self.send_response(status) |
| all_headers = self._security_headers() |
| if headers: |
| all_headers.update(headers) |
| all_headers["Content-Type"] = content_type |
| all_headers["Content-Length"] = str(len(body)) |
| for key, value in all_headers.items(): |
| self.send_header(key, value) |
| for cookie in cookies or []: |
| self.send_header("Set-Cookie", cookie) |
| self.end_headers() |
| if self.command != "HEAD" and body: |
| try: |
| self.wfile.write(body) |
| except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError): |
| |
| |
| |
| |
| self.close_connection = True |
|
|
| def _send_html( |
| self, |
| status: int, |
| html: str, |
| *, |
| cookies: list[str] | None = None, |
| headers: dict[str, str] | None = None, |
| ) -> None: |
| self._send(status, html.encode("utf-8"), cookies=cookies, headers=headers) |
|
|
| def _send_json( |
| self, |
| status: int, |
| payload: Mapping[str, Any], |
| *, |
| cookies: list[str] | None = None, |
| headers: dict[str, str] | None = None, |
| ) -> None: |
| self._send( |
| status, |
| json_bytes(payload), |
| content_type="application/json; charset=utf-8", |
| cookies=cookies, |
| headers=headers, |
| ) |
|
|
| def _request_cookies(self) -> SimpleCookie[str]: |
| jar: SimpleCookie[str] = SimpleCookie() |
| raw = self.headers.get("Cookie", "") |
| if raw: |
| try: |
| jar.load(raw) |
| except Exception: |
| pass |
| return jar |
|
|
| def _session(self) -> tuple[str, str, list[str]]: |
| jar = self._request_cookies() |
| morsel = jar.get(SESSION_COOKIE) |
| token = morsel.value if morsel and len(morsel.value) >= 32 else secrets.token_urlsafe(SESSION_BYTES) |
| session_digest = digest(token) |
| self.store.ensure_session(session_digest) |
| |
| |
| |
| views.set_delivery_context( |
| self.store.delivery_country(session_digest), |
| delivery_location_token(session_digest), |
| ) |
| cookies: list[str] = [] |
| if morsel is None or morsel.value != token: |
| cookies.append(browser_cookie(SESSION_COOKIE, token)) |
| return token, session_digest, cookies |
|
|
| def _rotate_authenticated_session( |
| self, session_digest: str, cookies: list[str] |
| ) -> str: |
| token = secrets.token_urlsafe(SESSION_BYTES) |
| new_session_digest = digest(token) |
| self.store.rotate_authenticated_session(session_digest, new_session_digest) |
| cookies[:] = [browser_cookie(SESSION_COOKIE, token)] |
| return new_session_digest |
|
|
| def _mail_mode(self) -> str: |
| return MAIL_SMTP_PENDING if self.smtp_config is not None else MAIL_LOCAL_ONLY |
|
|
| def _auth_mail_status( |
| self, session_digest: str, purpose: str |
| ) -> dict[str, Any] | None: |
| if purpose == "password-reset": |
| pending = self.store.pending_password_reset(session_digest) |
| if pending is not None and pending.get("verified"): |
| status = self.store.password_reset_mail_status(session_digest) |
| if ( |
| self.smtp_config is None |
| and status is not None |
| and status.get("status") in {"SMTP_PENDING", "SMTP_FAILED"} |
| ): |
| return { |
| "status": MAIL_LOCAL_ONLY, |
| "delivery_attempts": status.get("delivery_attempts", 0), |
| "can_retry": False, |
| } |
| return status |
| |
| |
| |
| return { |
| "status": "QUEUED", |
| "delivery_attempts": 0, |
| "can_retry": False, |
| } |
| status = self.store.registration_mail_status(session_digest) |
| if ( |
| self.smtp_config is None |
| and status is not None |
| and status.get("status") in {"SMTP_PENDING", "SMTP_FAILED"} |
| ): |
| return { |
| "status": MAIL_LOCAL_ONLY, |
| "delivery_attempts": status.get("delivery_attempts", 0), |
| "can_retry": False, |
| } |
| return status |
|
|
| def _public_order_mail_state(self, order: dict[str, Any]) -> dict[str, Any]: |
| email = order.get("email") |
| if ( |
| self.smtp_config is None |
| and isinstance(email, dict) |
| and email.get("status") in {"SMTP_PENDING", "SMTP_FAILED"} |
| ): |
| return { |
| **order, |
| "email": { |
| **email, |
| "status": MAIL_LOCAL_ONLY, |
| "is_simulation": True, |
| "can_retry": False, |
| }, |
| } |
| return order |
|
|
| def _dispatch_mail(self, delivery: dict[str, Any] | None) -> None: |
| """Attempt configured SMTP asynchronously so reset responses stay uniform.""" |
|
|
| config = self.smtp_config |
| if delivery is None or config is None: |
| return |
| dispatch_mail_delivery(self.store, config, delivery) |
|
|
| def _flow_digest(self) -> str: |
| morsel = self._request_cookies().get(FLOW_COOKIE) |
| return digest(morsel.value) if morsel else "" |
|
|
| def _referer(self) -> str: |
| return self.headers.get("Referer", "") |
|
|
| def _signin_location_for_cart_mutation(self) -> str: |
| referer = urlsplit(self._referer()) |
| return_candidate = "" |
| if ( |
| referer.scheme in {"http", "https"} |
| and referer.netloc.casefold() == self.headers.get("Host", "").casefold() |
| and referer.path.startswith("/") |
| ): |
| return_candidate = referer.path |
| if referer.query: |
| return_candidate += "?" + referer.query |
| return_to = auth_views.safe_return_target( |
| {"openid.return_to": [return_candidate]} |
| ) or "/gp/cart/view.html" |
| return "/ap/signin?" + urlencode({"openid.return_to": return_to}) |
|
|
| def _same_origin_path(self, raw_url: str, expected_path: str) -> bool: |
| parsed = urlsplit(raw_url) |
| return bool( |
| parsed.scheme in {"http", "https"} |
| and parsed.netloc == self.headers.get("Host", "") |
| and parsed.path == expected_path |
| ) |
|
|
| def _terminal_source_is_canonical(self) -> bool: |
| referer_ok = self._same_origin_path(self._referer(), PDP_PATH) |
| origin = self.headers.get("Origin", "") |
| if not origin: |
| return referer_ok |
| parsed = urlsplit(origin) |
| return referer_ok and parsed.scheme in {"http", "https"} and parsed.netloc == self.headers.get("Host", "") |
|
|
| def _form_fields(self, raw_body: bytes) -> dict[str, str] | None: |
| media_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower() |
| if media_type != "application/x-www-form-urlencoded": |
| return None |
| try: |
| pairs = parse_qsl( |
| raw_body.decode("utf-8"), |
| keep_blank_values=True, |
| strict_parsing=True, |
| max_num_fields=16, |
| ) |
| except (UnicodeDecodeError, ValueError): |
| return None |
| fields: dict[str, str] = {} |
| for name, value in pairs: |
| if name in fields: |
| return None |
| fields[name] = value |
| return fields |
|
|
| def _json_fields( |
| self, raw_body: bytes, expected_fields: frozenset[str] |
| ) -> dict[str, str] | None: |
| media_type = ( |
| self.headers.get("Content-Type", "") |
| .split(";", 1)[0] |
| .strip() |
| .lower() |
| ) |
| if ( |
| media_type != "application/json" |
| or not raw_body |
| or len(raw_body) > MAX_AUTH_JSON_BYTES |
| ): |
| return None |
| try: |
| payload = json.loads(raw_body.decode("utf-8")) |
| except (UnicodeDecodeError, json.JSONDecodeError): |
| return None |
| if ( |
| not isinstance(payload, dict) |
| or set(payload) != expected_fields |
| or any(not isinstance(payload[name], str) for name in expected_fields) |
| ): |
| return None |
| return {name: payload[name] for name in expected_fields} |
|
|
| def _external_client_address(self) -> str: |
| candidate = self.client_address[0] |
| if env_flag("AMAZON_TRUST_PROXY_HEADERS") or cloudflare_review_profile(): |
| candidate = self.headers.get( |
| "X-WebsiteBench-Client-IP", "" |
| ).strip() |
| try: |
| return str(ipaddress.ip_address(candidate)) |
| except ValueError: |
| |
| |
| return "unknown" |
|
|
| def _expected_request_authority(self) -> tuple[str, str]: |
| scheme = ( |
| "https" |
| if env_flag("AMAZON_COOKIE_SECURE") or cloudflare_review_profile() |
| else "http" |
| ) |
| authority = self.headers.get("Host", "") |
| if env_flag("AMAZON_TRUST_PROXY_HEADERS") or cloudflare_review_profile(): |
| forwarded_scheme = self.headers.get("X-Forwarded-Proto", "").strip() |
| forwarded_authority = self.headers.get( |
| "X-Forwarded-Host", "" |
| ).strip() |
| if forwarded_scheme in {"http", "https"}: |
| scheme = forwarded_scheme |
| if forwarded_authority: |
| authority = forwarded_authority |
| return scheme, authority.casefold() |
|
|
| def _auth_post_origin_is_safe(self) -> bool: |
| origin = self.headers.get("Origin", "") |
| candidate = origin or self.headers.get("Referer", "") |
| if not candidate: |
| return False |
| parsed = urlsplit(candidate) |
| expected_scheme, expected_authority = self._expected_request_authority() |
| return ( |
| parsed.scheme == expected_scheme |
| and parsed.netloc.casefold() == expected_authority |
| ) |
|
|
| def _delivery_return_location(self, *, error: bool) -> str: |
| """Where to send the browser after a delivery-location submission. |
| |
| The source storefront re-renders whatever page the picker was opened |
| from. Only the path and query of a same-authority Referer are reused, |
| so this can never become an open redirect. |
| """ |
|
|
| target = "/" |
| referer = self.headers.get("Referer", "") |
| if referer: |
| parsed = urlsplit(referer) |
| expected_scheme, expected_authority = self._expected_request_authority() |
| same_origin = ( |
| parsed.scheme == expected_scheme |
| and parsed.netloc.casefold() == expected_authority |
| ) |
| if same_origin and parsed.path.startswith("/"): |
| target = parsed.path |
| retained = [ |
| (name, value) |
| for name, value in parse_qsl(parsed.query, keep_blank_values=True) |
| if name != "locationError" |
| ] |
| if retained: |
| target += "?" + urlencode(retained) |
| if error: |
| target += "&" if "?" in target else "?" |
| target += "locationError=1" |
| return target |
|
|
| def _stripe_return_urls(self) -> tuple[str, str]: |
| scheme, authority = self._expected_request_authority() |
| if not authority: |
| raise ContractError("checkout request authority is unavailable") |
| root = f"{scheme}://{authority}" |
| placeholder = "{CHECKOUT_SESSION_ID}" |
| success = ( |
| root |
| + STRIPE_RETURN_PATH |
| + "?session_id=" |
| + placeholder |
| ) |
| cancel = ( |
| root |
| + STRIPE_RETURN_PATH |
| + "?cancelled=1&session_id=" |
| + placeholder |
| ) |
| return success, cancel |
|
|
| def _handle_stripe_webhook(self) -> None: |
| config = self.payment_config |
| gateway = self.stripe_gateway |
| if not config.stripe_enabled or gateway is None: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| ) |
| return |
| try: |
| content_length = int( |
| self.headers.get("Content-Length", "0") or "0" |
| ) |
| except ValueError: |
| self._send( |
| 400, |
| b"Invalid Content-Length", |
| content_type="text/plain; charset=utf-8", |
| ) |
| return |
| if ( |
| content_length <= 0 |
| or content_length > STRIPE_WEBHOOK_MAX_BYTES |
| ): |
| self.close_connection = True |
| self._send( |
| 413, |
| b"Webhook body is too large", |
| content_type="text/plain; charset=utf-8", |
| headers={"Connection": "close"}, |
| ) |
| return |
| raw_body = self.rfile.read(content_length) |
| try: |
| if config.trust_edge_webhook: |
| if ( |
| self.headers.get("X-WebsiteBench-Stripe-Verified", "") |
| != "1" |
| ): |
| raise StripeSignatureError( |
| "edge webhook verification is required" |
| ) |
| else: |
| assert config.webhook_secret is not None |
| verify_stripe_signature( |
| raw_body, |
| self.headers.get("Stripe-Signature", ""), |
| config.webhook_secret, |
| ) |
| event = json.loads(raw_body.decode("utf-8")) |
| if not isinstance(event, dict): |
| raise ValueError("webhook event must be an object") |
| data = event.get("data") |
| provider_object = ( |
| data.get("object") |
| if isinstance(data, dict) |
| else None |
| ) |
| if ( |
| not isinstance(provider_object, dict) |
| or not isinstance(event.get("id"), str) |
| or not isinstance(event.get("type"), str) |
| or isinstance(event.get("created"), bool) |
| or not isinstance(event.get("created"), int) |
| ): |
| raise ValueError("webhook event shape is invalid") |
| session_id = str(provider_object.get("id") or "") |
| if STRIPE_PROVIDER_SESSION_PATTERN.fullmatch(session_id) is None: |
| raise ValueError("webhook Session ID is invalid") |
| except ( |
| UnicodeDecodeError, |
| json.JSONDecodeError, |
| StripeSignatureError, |
| ValueError, |
| ): |
| self._send_json(400, {"ok": False, "error": "invalid-webhook"}) |
| return |
| try: |
| provider_session = gateway.retrieve_checkout_session(session_id) |
| result = self.store.process_stripe_event( |
| str(event["id"]), |
| str(event["type"]), |
| int(event["created"]), |
| provider_session, |
| mail_mode=self._mail_mode(), |
| ) |
| except StripeAPIError: |
| self._send_json( |
| 503, |
| {"ok": False, "error": "stripe-temporarily-unavailable"}, |
| ) |
| return |
| except ContractError: |
| self._send_json( |
| 400, {"ok": False, "error": "invalid-webhook-event"} |
| ) |
| return |
| order_id = result.get("order_id") |
| if isinstance(order_id, int): |
| self._dispatch_mail(self.store.order_mail_delivery(order_id)) |
| self._send_json( |
| 200, |
| { |
| "ok": True, |
| "duplicate": bool(result.get("duplicate")), |
| "status": str(result.get("event_status") or "PROCESSED"), |
| }, |
| ) |
|
|
| def _serve_static(self, path: str) -> None: |
| relative = unquote(path.removeprefix("/static/")) |
| if relative == "auth-verification.js": |
| self._send( |
| 200, |
| registration_frontend_script(), |
| content_type="text/javascript; charset=utf-8", |
| headers={"Cache-Control": "no-cache"}, |
| ) |
| return |
| candidate = (STATIC_ROOT / relative).resolve() |
| if STATIC_ROOT not in candidate.parents or not candidate.is_file(): |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8") |
| return |
| content_type = mimetypes.guess_type(candidate.name)[0] or "application/octet-stream" |
| self._send( |
| 200, |
| candidate.read_bytes(), |
| content_type=content_type, |
| headers={"Cache-Control": "no-cache"}, |
| ) |
|
|
| def _send_product_page( |
| self, |
| product: dict[str, Any], |
| *, |
| cart_count: int, |
| flow_ready: bool, |
| account_name: str | None, |
| session_digest: str, |
| query: dict[str, list[str]], |
| path: str, |
| cookies: list[str], |
| ) -> None: |
| asin = str(product["asin"]) |
| default_options = self.store.default_product_options(asin) |
| option_quotes = self.store.product_option_quotes(asin) |
| default_quote = next( |
| ( |
| quote |
| for quote in option_quotes |
| if quote.get("selected_options") == default_options |
| ), |
| None, |
| ) |
| product = { |
| **compare_entry_product(self.store, product), |
| "default_selected_options": default_options, |
| "option_spec": self.store.product_option_spec(asin), |
| "option_quote_matrix": option_quotes, |
| "option_unavailable_copy": UNAVAILABLE_SELECTION_COPY, |
| "recommendations": self.store.product_recommendations(asin), |
| } |
| if default_quote is not None: |
| product.update( |
| { |
| "price_minor": int(default_quote["price_minor"]), |
| "currency": str(default_quote["currency"]), |
| "image_path": str(default_quote["image_path"]), |
| "availability": str(default_quote["display_availability"]), |
| } |
| ) |
| try: |
| review_star, review_sort = review_query_parameters(query) |
| except ReviewValidationError as exc: |
| self._send_html( |
| 400, |
| views.error_page(str(exc), cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| review_kwargs: dict[str, Any] = { |
| "local_reviews": self.store.reviews_for_session( |
| session_digest, product["asin"], sort=review_sort |
| ), |
| "review_star": review_star, |
| "review_sort": review_sort, |
| "review_base_path": path, |
| } |
| page = views.product_page( |
| product, |
| cart_count, |
| flow_ready, |
| account_name, |
| **review_kwargs, |
| ) |
| self._send_html(200, page, cookies=cookies) |
|
|
| def _render_search_view( |
| self, |
| search_request: SearchRequest, |
| cart_count: int, |
| account_name: str | None, |
| ) -> str: |
| """Build one deterministic page-family search model.""" |
|
|
| display_catalog = self.store.display_products() |
| display_by_asin = { |
| str(product["asin"]): product for product in display_catalog |
| } |
| category_tile = HOME_CATEGORY_QUERY_TILES.get( |
| normalize_search_query(search_request.query) |
| ) |
| if category_tile is not None: |
| products = [] |
| for source_index, category_product in enumerate(category_tile["products"]): |
| asin = str(category_product["asin"]) |
| offer = self.store.commerce_offer(asin) |
| if offer is None: |
| raise ContractError( |
| f"home category product has no server quote: {asin}" |
| ) |
| product = { |
| **dict(category_product), |
| **display_by_asin[asin], |
| **offer, |
| "category_key": category_product["category_key"], |
| "category_index": category_product["category_index"], |
| "category_label": category_product["category_label"], |
| "category_query": category_product["category_query"], |
| "source_search_url": category_product["source_search_url"], |
| } |
| default_options = self.store.default_product_options(asin) |
| product["default_selected_options"] = default_options |
| products.append( |
| build_search_hit( |
| product, |
| relevance=len(category_tile["products"]) - source_index, |
| source_index=source_index, |
| ) |
| ) |
| candidates = products |
| elif is_portable_ssd_contract_query(search_request.query): |
| products: list[dict[str, Any]] = [] |
| source_products: list[dict[str, Any]] = [] |
| frozen_by_asin = { |
| str(product["asin"]): product for product in self.store.products() |
| } |
| for asin in PORTABLE_SEARCH_ORDER: |
| source_product = frozen_by_asin[asin] |
| product = { |
| **dict(source_product), |
| **display_by_asin[str(source_product["asin"])], |
| } |
| |
| |
| |
| product["placements"] = [ |
| { |
| "railKey": "best-sellers-computers-accessories", |
| "railTitle": "Computers & Accessories", |
| } |
| ] |
| default_options = self.store.default_product_options(product["asin"]) |
| product["default_selected_options"] = default_options |
| for quote in self.store.product_option_quotes(product["asin"]): |
| if quote.get("selected_options") == default_options: |
| product["availability"] = quote.get("display_availability") |
| break |
| products.append(product) |
| source_products.append(dict(source_product)) |
| for source_product in BROWSE_BREADTH["portable_ssd_supplement"]: |
| products.append( |
| { |
| **dict(source_product), |
| **display_by_asin[str(source_product["asin"])], |
| } |
| ) |
| source_products.append(dict(source_product)) |
| total_candidates = len(products) |
| candidates = [ |
| replace( |
| build_search_hit( |
| product, |
| relevance=total_candidates - index, |
| source_index=index, |
| ), |
| |
| |
| |
| |
| brand=( |
| str(source_products[index]["brand"]) |
| if isinstance(source_products[index].get("brand"), str) |
| and str(source_products[index]["brand"]).strip() |
| else None |
| ), |
| ) |
| for index, product in enumerate(products) |
| ] |
| elif ( |
| search_request.department != "aps" |
| or source_department_for_query(search_request.query) is not None |
| or normalize_search_query(search_request.query) in FROZEN_SEARCH_QUERIES |
| ): |
| candidates = candidate_search_hits( |
| search_request, |
| HOME_PRODUCT_CATALOG, |
| SEARCH_DEPARTMENT_SUPPLEMENTS, |
| ) |
| enriched_candidates = [] |
| for hit in candidates: |
| enriched = build_search_hit( |
| { |
| **dict(hit.product), |
| **display_by_asin[hit.asin], |
| }, |
| relevance=hit.relevance, |
| source_index=hit.source_index, |
| ) |
| |
| |
| |
| enriched_candidates.append( |
| replace(enriched, departments=hit.departments) |
| ) |
| candidates = enriched_candidates |
| else: |
| candidates = candidate_search_hits( |
| search_request, |
| {str(product["asin"]): product for product in display_catalog}, |
| ) |
|
|
| eligible_asins = self.store.compare_eligible_asins() |
| candidates = [ |
| replace( |
| hit, |
| product=compare_entry_product( |
| self.store, |
| hit.product, |
| eligible_asins=eligible_asins, |
| ), |
| ) |
| for hit in candidates |
| ] |
|
|
| search_page = refine_search_hits(search_request, candidates, page_size=16) |
| visible_candidates = [ |
| hit |
| for hit in candidates |
| if search_request.department == "aps" |
| or search_request.department in hit.departments |
| ] |
| available_brands = tuple( |
| dict.fromkeys( |
| hit.brand for hit in visible_candidates if hit.brand is not None |
| ) |
| ) |
| price_ranges = ( |
| (None, 2499), |
| (2500, 4999), |
| (5000, 9999), |
| (10000, 19999), |
| (20000, None), |
| ) |
| available_facets = { |
| "departments": tuple( |
| dict.fromkeys( |
| department |
| for hit in candidates |
| for department in hit.departments |
| ) |
| ), |
| "brand": bool(available_brands), |
| "price_ranges": tuple( |
| (minimum, maximum) |
| for minimum, maximum in price_ranges |
| if any( |
| hit.price_minor is not None |
| and (minimum is None or hit.price_minor >= minimum) |
| and (maximum is None or hit.price_minor <= maximum) |
| for hit in visible_candidates |
| ) |
| ), |
| "rating": any( |
| hit.rating_value is not None and hit.rating_value >= 4 |
| for hit in visible_candidates |
| ), |
| "availability": any( |
| hit.availability == "in-stock" for hit in visible_candidates |
| ), |
| } |
| return views.search_results_page( |
| search_page, |
| cart_count, |
| account_name, |
| available_brands=available_brands, |
| available_facets=available_facets, |
| result_layout="grid" if category_tile is not None else "list", |
| department_rail_products=( |
| [ |
| product |
| for product in display_catalog |
| if search_request.department == "computers" |
| and str(product.get("brand") or "").casefold() == "sandisk" |
| ] |
| if not search_request.query |
| else [] |
| ), |
| ) |
|
|
| def do_HEAD(self) -> None: |
| self.do_GET() |
|
|
| def do_GET(self) -> None: |
| request = urlsplit(self.path) |
| path = request.path or "/" |
| if path == "/healthz": |
| try: |
| self.store.meta() |
| except Exception: |
| self._send( |
| 503, |
| json_bytes({"ok": False}), |
| content_type="application/json; charset=utf-8", |
| ) |
| return |
| build_id = os.environ.get("DEPLOYMENT_BUILD_ID", "") |
| build_headers = ( |
| {"X-WebsiteBench-Container-Build-ID": build_id} |
| if re.fullmatch(r"[0-9a-f]{40}", build_id) |
| else None |
| ) |
| self._send( |
| 200, |
| json_bytes({"ok": True}), |
| content_type="application/json; charset=utf-8", |
| headers=build_headers, |
| ) |
| return |
| if not self._require_public_basic_auth(): |
| return |
| try: |
| query = parse_qs( |
| request.query, keep_blank_values=True, max_num_fields=64 |
| ) |
| except ValueError: |
| self._send( |
| 400, |
| b"Too many query parameters.", |
| content_type="text/plain; charset=utf-8", |
| ) |
| return |
|
|
| if path.startswith("/static/"): |
| self._serve_static(path) |
| return |
| if path.startswith("/__bench/"): |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8") |
| return |
| if path == "/robots.txt": |
| self._send(200, b"User-agent: *\nDisallow: /__bench/\n", content_type="text/plain; charset=utf-8") |
| return |
|
|
| _, session_digest, cookies = self._session() |
| cart_count = self.store.cart_count(session_digest) |
| current_account = self.store.account_for_session(session_digest) |
| account_name = ( |
| str(current_account["display_name"]) if current_account is not None else None |
| ) |
| referer = self._referer() |
|
|
| if path == STRIPE_RETURN_PATH: |
| if ( |
| not self.payment_config.stripe_enabled |
| or self.stripe_gateway is None |
| ): |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| if current_account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": STRIPE_RETURN_PATH} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| session_values = query.get("session_id", []) |
| session_id = ( |
| session_values[0] |
| if len(session_values) == 1 |
| and STRIPE_PROVIDER_SESSION_PATTERN.fullmatch( |
| session_values[0] |
| ) |
| else "" |
| ) |
| mapping = ( |
| self.store.stripe_checkout_for_session( |
| session_digest, session_id |
| ) |
| if session_id |
| else None |
| ) |
| if mapping is None: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| try: |
| provider_session = ( |
| self.stripe_gateway.retrieve_checkout_session(session_id) |
| ) |
| order = self.store.confirm_stripe_return( |
| session_digest, |
| session_id, |
| provider_session, |
| mail_mode=self._mail_mode(), |
| ) |
| except StripeAPIError: |
| self._send_html( |
| 503, |
| views.stripe_payment_status_page( |
| mapping, |
| cart_count, |
| account_name or "Customer", |
| session_id=session_id, |
| state="unavailable", |
| cancelled=False, |
| ), |
| cookies=cookies, |
| ) |
| return |
| except ContractError: |
| self._send_html( |
| 409, |
| views.stripe_payment_status_page( |
| mapping, |
| cart_count, |
| account_name or "Customer", |
| session_id=session_id, |
| state="mismatch", |
| cancelled=False, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if order is not None: |
| self._dispatch_mail( |
| self.store.order_mail_delivery(order["order_id"]) |
| ) |
| location = ORDER_DETAIL_PATH + "?" + urlencode( |
| {"orderID": order["order_id"]} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| cancelled = query.get("cancelled", []) == ["1"] |
| self._send_html( |
| 200, |
| views.stripe_payment_status_page( |
| mapping, |
| cart_count, |
| account_name or "Customer", |
| session_id=session_id, |
| state=str( |
| provider_session.get("payment_status") or "unpaid" |
| ), |
| cancelled=cancelled, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == SEARCH_SUGGESTIONS_PATH: |
| try: |
| suggestion_request = parse_suggestion_request(request.query) |
| suggestions = suggest_search_terms( |
| suggestion_request, SEARCH_SUGGESTION_CORPUS |
| ) |
| except SearchSuggestionValidationError as exc: |
| self.store.record_read_route( |
| session_digest, |
| "SEARCH_SUGGESTIONS", |
| path, |
| referer, |
| status=400, |
| ) |
| self._send( |
| 400, |
| json_bytes({"error": str(exc)}), |
| content_type="application/json; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, "SEARCH_SUGGESTIONS", path, referer |
| ) |
| self._send( |
| 200, |
| json_bytes( |
| { |
| "department": suggestion_request.department, |
| "query": suggestion_request.query, |
| "suggestions": [ |
| { |
| "department": suggestion.department, |
| "kind": suggestion.kind, |
| "value": suggestion.value, |
| } |
| for suggestion in suggestions |
| ], |
| } |
| ), |
| content_type="application/json; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == AUTH_SIGNOUT_PATH: |
| self._send( |
| 405, |
| b"Sign out requires POST.", |
| content_type="text/plain; charset=utf-8", |
| headers={"Allow": "POST"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in {"/", "/ref=nav_logo"}: |
| self.store.record_read_route(session_digest, "HOME", path, referer) |
| page = views.home_page(self.store.products(), cart_count, account_name) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| home_collection_match = HOME_COLLECTION_ROUTE.fullmatch(path) |
| if home_collection_match: |
| collection_key, tile_value = home_collection_match.groups() |
| tile_index = int(tile_value) if tile_value is not None else None |
| group = HOME_CATEGORY_GROUPS.get(collection_key) |
| if group is None or ( |
| tile_index is not None and tile_index not in range(1, 5) |
| ): |
| self.store.record_read_route( |
| session_digest, |
| "HOME_COLLECTION_NOT_FOUND", |
| path, |
| referer, |
| status=404, |
| ) |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| destination = views.home_collection_href(collection_key, tile_index) |
| self.store.record_read_route( |
| session_digest, "HOME_COLLECTION_REDIRECT", path, referer |
| ) |
| self._send( |
| 302, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == "/Best-Sellers/zgbs": |
| self.store.record_read_route(session_digest, "BEST_SELLERS_ROOT", path, referer) |
| page = views.best_sellers_root(self.store.products(), cart_count, account_name) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == BEST_SELLERS_PATH: |
| self.store.record_best_sellers(session_digest, path, referer) |
| page = views.external_ssd_best_sellers(self.store.ranking(), cart_count, account_name) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == PDP_PATH: |
| capability = secrets.token_urlsafe(SESSION_BYTES) |
| flow_ready = self.store.record_pdp( |
| session_digest, |
| path, |
| referer, |
| digest(capability), |
| self._same_origin_path(referer, BEST_SELLERS_PATH), |
| ) |
| if flow_ready: |
| cookies.append(browser_cookie(FLOW_COOKIE, capability)) |
| product = product_for_pdp(self.store, TARGET_ASIN) |
| assert product is not None |
| self._send_product_page( |
| product, |
| cart_count=cart_count, |
| flow_ready=flow_ready, |
| account_name=account_name, |
| session_digest=session_digest, |
| query=query, |
| path=path, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == f"/gp/aw/d/{TARGET_ASIN}": |
| self.store.record_read_route(session_digest, "TARGET_PDP_MOBILE_ALIAS", path, referer) |
| product = product_for_pdp(self.store, TARGET_ASIN) |
| assert product is not None |
| self._send_product_page( |
| product, |
| cart_count=cart_count, |
| flow_ready=False, |
| account_name=account_name, |
| session_digest=session_digest, |
| query=query, |
| path=path, |
| cookies=cookies, |
| ) |
| return |
|
|
| bare_product_match = BARE_PDP_ROUTE.fullmatch(path) |
| if bare_product_match: |
| asin = bare_product_match.group(1) |
| product = product_for_pdp(self.store, asin) |
| if product is not None: |
| self.store.record_read_route(session_digest, "HOME_PRODUCT_DETAIL", path, referer) |
| self._send_product_page( |
| product, |
| cart_count=cart_count, |
| flow_ready=False, |
| account_name=account_name, |
| session_digest=session_digest, |
| query=query, |
| path=path, |
| cookies=cookies, |
| ) |
| return |
|
|
| product_match = PDP_ROUTE.fullmatch(path) |
| if product_match: |
| slug, asin = product_match.groups() |
| product = product_for_pdp(self.store, asin) |
| if product is not None and product["slug"] == slug: |
| self.store.record_read_route(session_digest, "PRODUCT_DETAIL", path, referer) |
| self._send_product_page( |
| product, |
| cart_count=cart_count, |
| flow_ready=False, |
| account_name=account_name, |
| session_digest=session_digest, |
| query=query, |
| path=path, |
| cookies=cookies, |
| ) |
| return |
|
|
| product_reviews_match = PRODUCT_REVIEWS_ROUTE.fullmatch(path) |
| if product_reviews_match: |
| asin = product_reviews_match.group(1) |
| product = product_for_pdp(self.store, asin) |
| if product is None: |
| self.store.record_read_route( |
| session_digest, "PRODUCT_REVIEWS_NOT_FOUND", path, referer, status=404 |
| ) |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
| return |
| try: |
| review_star, review_sort = review_query_parameters(query) |
| local_reviews = self.store.reviews_for_session( |
| session_digest, asin, sort=review_sort |
| ) |
| except ReviewValidationError as exc: |
| self._send_html( |
| 400, |
| views.error_page(str(exc), cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| review_html = render_reviews_section( |
| asin, |
| local_reviews, |
| star=review_star, |
| sort=review_sort, |
| account_name=account_name, |
| base_path=path, |
| product_label=str(product["title"]), |
| ) |
| self.store.record_read_route( |
| session_digest, "PRODUCT_REVIEWS", path, referer |
| ) |
| self._send_html( |
| 200, |
| views.product_reviews_page( |
| product, review_html, cart_count, account_name |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in {"/s", "/s/ref=nb_sb_noss"}: |
| try: |
| search_request = parse_search_request(request.query) |
| page = self._render_search_view( |
| search_request, cart_count, account_name |
| ) |
| except SearchValidationError as exc: |
| self.store.record_read_route( |
| session_digest, "SEARCH", path, referer, status=400 |
| ) |
| self._send_html( |
| 400, |
| views.error_page(str(exc), cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route(session_digest, "SEARCH", path, referer) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == "/gp/cart/view.html": |
| self.store.record_read_route(session_digest, "CART", path, referer) |
| lines = self.store.cart(session_digest) |
| saved_lines = self.store.saved_cart(session_digest) |
| page = views.cart_page( |
| lines, |
| self.store.cart_count(session_digest), |
| account_name, |
| saved_lines=saved_lines, |
| recommendation_products=self.store.product_recommendations( |
| "B0874XN4D8" |
| ), |
| ) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == ADD_TO_CART_CONFIRMATION_PATH: |
| line_id_values = query.get("lineID", []) |
| if set(query) != {"lineID"} or len(line_id_values) != 1: |
| self._send_html( |
| 400, |
| views.error_page("The added item could not be identified.", cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| line_id = line_id_values[0] |
| if CART_LINE_ID_PATTERN.fullmatch(line_id) is None: |
| self._send_html( |
| 400, |
| views.error_page("The added cart line is invalid.", cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| matching_lines = [ |
| line |
| for line in self.store.cart(session_digest) |
| if line["line_id"] == line_id |
| ] |
| line = matching_lines[0] if matching_lines else None |
| product = ( |
| product_for_pdp(self.store, str(line["asin"])) |
| if line is not None |
| else None |
| ) |
| if product is None or line is None: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, "ADD_TO_CART_CONFIRMATION", path, referer |
| ) |
| self._send_html( |
| 200, |
| views.cart_added_page( |
| {**product, **line}, |
| self.store.cart(session_digest), |
| self.store.cart_count(session_digest), |
| account_name, |
| recommendation_products=self.store.product_recommendations( |
| str(product["asin"]) |
| ), |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == COMPARE_PATH: |
| compare_products = [ |
| compare_product_for_view(self.store, item) |
| for item in self.store.compare_items(session_digest) |
| ] |
| error = (query.get("error") or [None])[0] |
| self.store.record_read_route(session_digest, "COMPARE", path, referer) |
| self._send_html( |
| 200, |
| views.compare_page(compare_products, cart_count, account_name, error), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == SITE_DIRECTORY_PATH: |
| self.store.record_read_route(session_digest, "SITE_DIRECTORY", path, referer) |
| directory_sections = [] |
| for raw_section in BROWSE_BREADTH["rail_sections"]: |
| section = dict(raw_section) |
| section["products"] = [ |
| display |
| for product in raw_section.get("products", ()) |
| if (display := self.store.display_product(str(product["asin"]))) |
| is not None |
| ] |
| directory_sections.append(section) |
| page = views.site_directory_page( |
| directory_sections, |
| cart_count, |
| account_name, |
| ) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == "/gp/goldbox/": |
| self.store.record_read_route(session_digest, "TODAYS_DEALS", path, referer) |
| self._send_html( |
| 200, |
| views.deals_page( |
| build_deals_view(DEALS_CATALOG, query), |
| cart_count, |
| account_name, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == GIFT_CARDS_PATH: |
| self.store.record_read_route(session_digest, "GIFT_CARDS", path, referer) |
| self._send_html( |
| 200, |
| specialty_views.gift_cards_page(cart_count, account_name), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.GIFT_CARD_PREVIEW_PATH: |
| preview_values = query.get("previewID") |
| preview = ( |
| specialty.gift_card_preview( |
| self.store, session_digest, preview_values[0] |
| ) |
| if set(query) == {"previewID"} |
| and preview_values is not None |
| and len(preview_values) == 1 |
| else None |
| ) |
| if preview is None: |
| self.store.record_read_route( |
| session_digest, "GIFT_CARD_PREVIEW_NOT_FOUND", path, referer, status=404 |
| ) |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
| return |
| self.store.record_read_route( |
| session_digest, "GIFT_CARD_PREVIEW", path, referer |
| ) |
| self._send_html( |
| 200, |
| specialty_views.gift_card_preview_page( |
| preview, cart_count, account_name |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in { |
| specialty.GIFT_CARD_BALANCE_PATH, |
| specialty.GIFT_CARD_REDEEM_PATH, |
| }: |
| status_values = query.get("status") |
| if query and not ( |
| set(query) == {"status"} and status_values == ["not-applied"] |
| ): |
| self.store.record_read_route( |
| session_digest, "GIFT_CARD_BALANCE_INVALID", path, referer, status=400 |
| ) |
| self._send_html( |
| 400, |
| views.error_page("Check the request and try again.", cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| balance = specialty.gift_card_balance(self.store, session_digest) |
| self.store.record_read_route( |
| session_digest, "GIFT_CARD_BALANCE", path, referer |
| ) |
| self._send_html( |
| 200, |
| specialty_views.gift_card_balance_page( |
| balance, |
| cart_count, |
| account_name, |
| redemption_result=status_values == ["not-applied"], |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.SELL_PATH: |
| drafts = specialty.seller_drafts(self.store, session_digest) |
| self.store.record_read_route(session_digest, "SELL", path, referer) |
| self._send_html( |
| 200, |
| specialty_views.sell_page(drafts, cart_count, account_name), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.SELL_DRAFT_PATH: |
| draft_values = query.get("draftID") |
| draft = ( |
| specialty.seller_draft(self.store, session_digest, draft_values[0]) |
| if set(query) == {"draftID"} |
| and draft_values is not None |
| and len(draft_values) == 1 |
| else None |
| ) |
| if draft is None: |
| self.store.record_read_route( |
| session_digest, "SELL_DRAFT_NOT_FOUND", path, referer, status=404 |
| ) |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
| return |
| self.store.record_read_route(session_digest, "SELL_DRAFT", path, referer) |
| self._send_html( |
| 200, |
| specialty_views.seller_draft_page(draft, cart_count, account_name), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.REGISTRY_PATH: |
| own_registries = specialty.registries(self.store, session_digest) |
| self.store.record_read_route(session_digest, "REGISTRY", path, referer) |
| self._send_html( |
| 200, |
| specialty_views.registry_page( |
| own_registries, cart_count, account_name |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.REGISTRY_SEARCH_PATH: |
| search_values = query.get("query") |
| if not ( |
| set(query) == {"query"} |
| and search_values is not None |
| and len(search_values) == 1 |
| ): |
| self.store.record_read_route( |
| session_digest, "REGISTRY_SEARCH_INVALID", path, referer, status=400 |
| ) |
| self._send_html( |
| 400, |
| views.error_page("Check the search and try again.", cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| try: |
| normalized_query, results = specialty.search_registries( |
| self.store, session_digest, search_values[0] |
| ) |
| except specialty.SpecialtyValidationError: |
| self.store.record_read_route( |
| session_digest, "REGISTRY_SEARCH_INVALID", path, referer, status=400 |
| ) |
| self._send_html( |
| 400, |
| views.error_page("Check the search and try again.", cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route(session_digest, "REGISTRY_SEARCH", path, referer) |
| self._send_html( |
| 200, |
| specialty_views.registry_search_page( |
| normalized_query, results, cart_count, account_name |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.REGISTRY_DETAIL_PATH: |
| registry_values = query.get("registryID") |
| registry = ( |
| specialty.registry(self.store, session_digest, registry_values[0]) |
| if set(query) == {"registryID"} |
| and registry_values is not None |
| and len(registry_values) == 1 |
| else None |
| ) |
| if registry is None: |
| self.store.record_read_route( |
| session_digest, "REGISTRY_DETAIL_NOT_FOUND", path, referer, status=404 |
| ) |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
| return |
| self.store.record_read_route( |
| session_digest, "REGISTRY_DETAIL", path, referer |
| ) |
| self._send_html( |
| 200, |
| specialty_views.registry_detail_page( |
| registry, cart_count, account_name |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == specialty.PRIME_VIDEO_PATH: |
| self.store.record_read_route( |
| session_digest, "PRIME_VIDEO_PLACEHOLDER", path, referer |
| ) |
| self._send_html( |
| 200, |
| specialty_views.prime_video_page(cart_count, account_name), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == CUSTOMER_SERVICE_PATH: |
| node_id = (query.get("nodeId") or [CUSTOMER_SERVICE_NODE])[0].strip() |
| if node_id == SHIPPING_POLICIES_NODE: |
| route_key = "SHIPPING_POLICIES" |
| page = views.shipping_policies_page(cart_count, account_name) |
| elif node_id == RETURNS_REPLACEMENTS_NODE: |
| route_key = "RETURNS_REPLACEMENTS" |
| page = views.returns_replacements_page(cart_count, account_name) |
| elif node_id == CONDITIONS_OF_USE_NODE: |
| route_key = "CONDITIONS_OF_USE" |
| page = views.conditions_of_use_page(cart_count, account_name) |
| elif node_id == PRIVACY_NOTICE_NODE: |
| route_key = "PRIVACY_NOTICE" |
| page = views.privacy_notice_page(cart_count, account_name) |
| else: |
| route_key = "CUSTOMER_SERVICE" |
| help_query = (query.get("help_keywords") or [""])[0].strip() |
| page = views.customer_service_page( |
| cart_count, |
| account_name, |
| help_query=help_query, |
| ) |
| self.store.record_read_route(session_digest, route_key, path, referer) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == DELIVERY_PREFERENCE_PATH: |
| self.store.record_read_route( |
| session_digest, "DELIVERY_LOCATION", path, referer |
| ) |
| self._send_html( |
| 200, |
| views.delivery_location_page( |
| cart_count, |
| account_name, |
| error=bool(query.get("locationError")), |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == DELIVERY_SELECTIONS_PATH: |
| selected_code, selected_label = self.store.delivery_country(session_digest) |
| self.store.record_read_route( |
| session_digest, "DELIVERY_SELECTIONS", path, referer |
| ) |
| self._send_json( |
| 200, |
| { |
| "header": "Choose your location", |
| "destinationType": "COUNTRY", |
| "action": DELIVERY_PREFERENCE_PATH, |
| "token": delivery_location_token(session_digest), |
| "selected": selected_code, |
| "selectedLabel": selected_label, |
| "options": [ |
| {"code": code, "label": label} |
| for code, label in SUPPORTED_DELIVERY_COUNTRIES |
| ], |
| }, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in PUBLIC_NAVIGATION_LANDINGS: |
| title, copy, links = PUBLIC_NAVIGATION_LANDINGS[path] |
| self.store.record_read_route(session_digest, "PUBLIC_NAVIGATION", path, referer) |
| self._send_html( |
| 200, |
| views.navigation_landing_page( |
| title, |
| copy, |
| links, |
| cart_count, |
| account_name, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in AUTH_PATHS: |
| self.store.record_read_route(session_digest, "AUTH_FRONTEND", path, referer) |
| if path == "/ap/cvf/verify": |
| purpose = (query.get("purpose") or ["registration"])[0] |
| pending = ( |
| self.store.pending_password_reset(session_digest) |
| if purpose == "password-reset" |
| else self.store.pending_registration(session_digest) |
| ) |
| self._send_html( |
| 200, |
| auth_views.verification_page( |
| query, |
| masked_destination=(pending or {}).get("masked_email"), |
| mail_delivery_mode=( |
| "SMTP" if self.smtp_config is not None else "LOCAL_ONLY" |
| ), |
| mail_delivery=self._auth_mail_status( |
| session_digest, purpose |
| ), |
| local_inbox_url=self.local_inbox_url, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if path == "/ap/forgotpassword" and ( |
| (query.get("stage") or [""])[0].lower() == "reset-password" |
| ): |
| pending_reset = self.store.pending_password_reset(session_digest) |
| if not pending_reset or not pending_reset["verified"]: |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/ap/forgotpassword"}, |
| cookies=cookies, |
| ) |
| return |
| if ( |
| path == "/ap/register" |
| and self.external_registration_verification is not None |
| ): |
| page = auth_views.register_page( |
| query, external_verification=True |
| ) |
| else: |
| page = auth_views.page_for(path, query) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path in {ADDRESS_BOOK_PATH, ADDRESS_ADD_PATH, ADDRESS_EDIT_PATH}: |
| if current_account is None: |
| return_target = path |
| if path == ADDRESS_EDIT_PATH and request.query: |
| return_target += "?" + request.query |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": return_target} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| if path == ADDRESS_BOOK_PATH: |
| status_values = query.get("status", []) |
| status = ( |
| status_values[0] |
| if len(status_values) == 1 |
| and status_values[0] |
| in {"added", "updated", "deleted", "default"} |
| else None |
| ) |
| self.store.record_read_route( |
| session_digest, "ADDRESS_BOOK", path, referer |
| ) |
| self._send_html( |
| 200, |
| views.address_book_page( |
| self.store.addresses_for_session(session_digest), |
| cart_count, |
| account_name or "Customer", |
| status=status, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if path == ADDRESS_ADD_PATH: |
| self._send_html( |
| 200, |
| views.address_form_page( |
| None, cart_count, account_name or "Customer" |
| ), |
| cookies=cookies, |
| ) |
| return |
| address_values = query.get("addressID", []) |
| address = ( |
| self.store.address_for_session( |
| session_digest, address_values[0] |
| ) |
| if len(address_values) == 1 |
| else None |
| ) |
| if address is None: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| self._send_html( |
| 200, |
| views.address_form_page( |
| address, cart_count, account_name or "Customer" |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == BUY_NOW_CONTINUE_PATH: |
| if current_account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": BUY_NOW_CONTINUE_PATH} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| try: |
| checkout = self.store.resume_buy_now(session_digest) |
| except ContractError: |
| self._send_html( |
| 409, |
| views.error_page( |
| "This Buy Now offer is no longer available. Return to the product page and choose it again.", |
| cart_count, |
| 409, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if checkout is None: |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/gp/cart/view.html"}, |
| cookies=cookies, |
| ) |
| return |
| self._send( |
| 303, |
| b"", |
| headers={"Location": CHECKOUT_ADDRESS_PATH}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in { |
| CHECKOUT_ADDRESS_PATH, |
| CHECKOUT_DELIVERY_PATH, |
| CHECKOUT_PAYMENT_PATH, |
| CHECKOUT_START_PATH, |
| }: |
| if current_account is None: |
| location = "/ap/signin?" + urlencode({"openid.return_to": path}) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| checkout = self.store.reconcile_checkout(session_digest) |
| if path == CHECKOUT_ADDRESS_PATH and checkout is None: |
| try: |
| checkout = self.store.start_checkout(session_digest) |
| except ContractError: |
| self._send(303, b"", headers={"Location": "/gp/cart/view.html"}, cookies=cookies) |
| return |
| if checkout is None: |
| self._send(303, b"", headers={"Location": CHECKOUT_ADDRESS_PATH}, cookies=cookies) |
| return |
| stage = CHECKOUT_STAGE_ORDER.get(str(checkout.get("status")), -1) |
| if str(checkout.get("status")) == "PLACED" and checkout.get("order_id"): |
| location = ORDER_DETAIL_PATH + "?" + urlencode({"orderID": checkout["order_id"]}) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| reconciliation_reason = str( |
| checkout.get("reconciliation_reason") or "" |
| ) |
| notice_values = query.get("notice", []) |
| notice = ( |
| notice_values[0] |
| if len(notice_values) == 1 |
| and notice_values[0] |
| in { |
| "cart-changed", |
| "unsupported-delivery-country", |
| "payment-declined", |
| "payment-cancelled", |
| } |
| else "" |
| ) |
| if ( |
| path == CHECKOUT_START_PATH |
| and reconciliation_reason == "cart-changed" |
| and stage >= CHECKOUT_STAGE_ORDER["DELIVERY_SELECTED"] |
| ): |
| location = CHECKOUT_PAYMENT_PATH + "?" + urlencode( |
| {"notice": "cart-changed"} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| if ( |
| reconciliation_reason == "unsupported-delivery-country" |
| and path != CHECKOUT_ADDRESS_PATH |
| ): |
| location = CHECKOUT_ADDRESS_PATH + "?" + urlencode( |
| {"notice": "unsupported-delivery-country"} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| if reconciliation_reason: |
| checkout = {**checkout, "notice": reconciliation_reason} |
| elif notice: |
| checkout = {**checkout, "notice": notice} |
| checkout_item_count = sum( |
| int(item.get("quantity", 0)) |
| for item in checkout.get("items", []) |
| if isinstance(item, dict) |
| ) |
| if path == CHECKOUT_ADDRESS_PATH: |
| page = views.checkout_address_page(checkout, checkout_item_count, account_name or "Customer") |
| elif path == CHECKOUT_DELIVERY_PATH: |
| if stage < CHECKOUT_STAGE_ORDER["ADDRESS_SELECTED"]: |
| self._send(303, b"", headers={"Location": CHECKOUT_ADDRESS_PATH}, cookies=cookies) |
| return |
| page = views.checkout_delivery_page(checkout, checkout_item_count, account_name or "Customer") |
| elif path == CHECKOUT_PAYMENT_PATH: |
| if stage < CHECKOUT_STAGE_ORDER["DELIVERY_SELECTED"]: |
| self._send(303, b"", headers={"Location": CHECKOUT_DELIVERY_PATH}, cookies=cookies) |
| return |
| page = views.checkout_payment_page( |
| checkout, |
| checkout_item_count, |
| account_name or "Customer", |
| payment_mode=self.payment_config.mode, |
| ) |
| else: |
| if stage < CHECKOUT_STAGE_ORDER["PAYMENT_SELECTED"]: |
| fallback = ( |
| CHECKOUT_PAYMENT_PATH |
| if stage >= CHECKOUT_STAGE_ORDER["DELIVERY_SELECTED"] |
| else CHECKOUT_DELIVERY_PATH |
| if stage >= CHECKOUT_STAGE_ORDER["ADDRESS_SELECTED"] |
| else CHECKOUT_ADDRESS_PATH |
| ) |
| self._send(303, b"", headers={"Location": fallback}, cookies=cookies) |
| return |
| page = views.checkout_review_page( |
| checkout, |
| checkout_item_count, |
| account_name or "Customer", |
| payment_mode=self.payment_config.mode, |
| ) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == ORDER_DETAIL_PATH: |
| if current_account is None: |
| location = "/ap/signin?" + urlencode({"openid.return_to": path}) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| order_values = query.get("orderID", []) |
| order = ( |
| self.store.order_for_session(session_digest, order_values[0]) |
| if len(order_values) == 1 |
| else None |
| ) |
| if order is None: |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
| return |
| order = self._public_order_mail_state(order) |
| self._send_html( |
| 200, |
| views.order_confirmation_page(order, cart_count, account_name or "Customer"), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in {RETURN_CREATE_PATH, RETURN_DETAIL_PATH}: |
| if current_account is None: |
| return_target = path + ("?" + request.query if request.query else "") |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": return_target} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| if path == RETURN_CREATE_PATH: |
| order_values = query.get("orderID", []) |
| order = ( |
| self.store.order_for_session(session_digest, order_values[0]) |
| if len(order_values) == 1 |
| else None |
| ) |
| if order is None: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| existing_return = order.get("return_request") |
| if isinstance(existing_return, dict): |
| location = RETURN_DETAIL_PATH + "?" + urlencode( |
| {"returnID": existing_return["return_request_id"]} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| if not order.get("can_return"): |
| self._send_html( |
| 409, |
| views.error_page( |
| "This simulated order is not eligible for a return request in its current state.", |
| cart_count, |
| 409, |
| ), |
| cookies=cookies, |
| ) |
| return |
| self._send_html( |
| 200, |
| views.return_request_page( |
| order, cart_count, account_name or "Customer" |
| ), |
| cookies=cookies, |
| ) |
| return |
| return_values = query.get("returnID", []) |
| order = ( |
| self.store.return_for_session(session_digest, return_values[0]) |
| if len(return_values) == 1 |
| else None |
| ) |
| if order is None: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| self._send_html( |
| 200, |
| views.return_details_page( |
| order, cart_count, account_name or "Customer" |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == wishlist_views.WISHLIST_INTRO_PATH: |
| if current_account is not None: |
| self._send( |
| 303, |
| b"", |
| headers={"Location": wishlist_views.WISHLIST_INDEX_PATH}, |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, "WISHLIST_INTRO", path, referer |
| ) |
| self._send_html( |
| 200, |
| wishlist_views.wishlist_intro_page(cart_count), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == WISHLIST_FRIENDS_PATH: |
| if current_account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": WISHLIST_FRIENDS_PATH} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, "WISHLIST_FRIENDS_BOUNDARY", path, referer |
| ) |
| self._send_html( |
| 200, |
| views.navigation_landing_page( |
| "Your Friends' Lists", |
| "Shared-list invitations are outside this local shopping clone. Your private Lists and Registry shopping remain available.", |
| ( |
| ("Open Your Lists", wishlist_views.WISHLIST_INDEX_PATH), |
| ("Open Gift Registries", "/gp/browse.html?node=16115931011"), |
| ), |
| cart_count, |
| account_name, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in { |
| wishlist_views.WISHLIST_INDEX_PATH, |
| wishlist_views.WISHLIST_ADD_CHOOSER_PATH, |
| }: |
| if current_account is None: |
| return_target = path + (f"?{request.query}" if request.query else "") |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": return_target} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
|
|
| if path == wishlist_views.WISHLIST_ADD_CHOOSER_PATH: |
| selection_query = wishlist_selection_query(query) |
| if selection_query is None: |
| self._send( |
| 400, |
| b"Malformed Add to List request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| asin, requested_options = selection_query |
| try: |
| product, selected_options = ( |
| wishlist.product_selection_for_wishlist( |
| self.store, asin, requested_options |
| ) |
| ) |
| wishlists = wishlist.lists_for_session( |
| self.store, session_digest |
| ) |
| except wishlist.WishlistAuthenticationRequired: |
| return_target = path + ( |
| f"?{request.query}" if request.query else "" |
| ) |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": return_target} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| except wishlist.WishlistNotFound: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| except wishlist.WishlistValidationError as exc: |
| self._send_html( |
| 400, |
| views.error_page(str(exc), cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, "WISHLIST_ADD_CHOOSER", path, referer |
| ) |
| self._send_html( |
| 200, |
| wishlist_views.wishlist_add_chooser_page( |
| product, |
| selected_options, |
| wishlists, |
| cart_count, |
| account_name or "Customer", |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if set(query) - {"listID", "status"} or any( |
| len(values) != 1 for values in query.values() |
| ): |
| self._send( |
| 400, |
| b"Malformed Wishlist request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| status_messages = { |
| "created": "List created.", |
| "renamed": "List renamed.", |
| "deleted": "List deleted.", |
| "added": "Added to List.", |
| "already-added": "This item was already on the List.", |
| "removed": "Item removed from List.", |
| } |
| status_values = query.get("status", []) |
| status_token = status_values[0] if status_values else "" |
| if status_token and status_token not in status_messages: |
| self._send( |
| 400, |
| b"Malformed Wishlist status", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| wishlists = wishlist.lists_for_session( |
| self.store, session_digest |
| ) |
| list_values = query.get("listID", []) |
| if list_values: |
| selected_list = wishlist.list_for_session( |
| self.store, session_digest, list_values[0] |
| ) |
| page = wishlist_views.wishlist_detail_page( |
| selected_list, |
| wishlists, |
| cart_count, |
| account_name or "Customer", |
| status=status_messages.get(status_token, ""), |
| ) |
| route_kind = "WISHLIST_DETAIL" |
| else: |
| page = wishlist_views.wishlist_index_page( |
| wishlists, |
| cart_count, |
| account_name or "Customer", |
| status=status_messages.get(status_token, ""), |
| ) |
| route_kind = "WISHLIST_INDEX" |
| except wishlist.WishlistAuthenticationRequired: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": wishlist_views.WISHLIST_INDEX_PATH} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| except wishlist.WishlistNotFound: |
| self._send_html( |
| 404, views.not_found_page(cart_count), cookies=cookies |
| ) |
| return |
| except wishlist.WishlistValidationError as exc: |
| self._send_html( |
| 400, |
| views.error_page(str(exc), cart_count, 400), |
| cookies=cookies, |
| ) |
| return |
| self.store.record_read_route( |
| session_digest, route_kind, path, referer |
| ) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| if path == "/gp/css/order-history" and current_account is not None: |
| orders = [ |
| self._public_order_mail_state(order) |
| for order in self.store.orders_for_session(session_digest) |
| ] |
| self.store.record_read_route(session_digest, "ORDERS", path, referer) |
| self._send_html( |
| 200, |
| views.order_history_page(orders, cart_count, account_name or "Customer"), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in PROTECTED_ACCOUNT_PATHS: |
| if current_account is None: |
| location = "/ap/signin?" + urlencode({"openid.return_to": path}) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| self.store.record_read_route(session_digest, "ACCOUNT", path, referer) |
| self._send_html(200, views.account_page(current_account, cart_count), cookies=cookies) |
| return |
|
|
| if path.startswith(("/electronics-store/", "/computer-pc-", "/External-Solid-State-Drives/")): |
| self.store.record_read_route(session_digest, "CATEGORY", path, referer) |
| page = self._render_search_view( |
| parse_search_request("k=portable+ssd&i=computers"), |
| cart_count, |
| account_name, |
| ) |
| self._send_html(200, page, cookies=cookies) |
| return |
|
|
| self.store.record_read_route(session_digest, "NOT_FOUND", path, referer, status=404) |
| self._send_html(404, views.not_found_page(cart_count), cookies=cookies) |
|
|
| def do_POST(self) -> None: |
| request = urlsplit(self.path) |
| path = request.path |
| if path == STRIPE_WEBHOOK_PATH: |
| self._handle_stripe_webhook() |
| return |
| if not self._require_public_basic_auth(): |
| return |
| query = parse_qs(request.query, keep_blank_values=True) |
| _, session_digest, cookies = self._session() |
| try: |
| content_length = int(self.headers.get("Content-Length", "0") or "0") |
| except ValueError: |
| self._send(400, b"Invalid Content-Length", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if content_length < 0 or content_length > MAX_FORM_BYTES: |
| |
| |
| |
| self.close_connection = True |
| self._send_html( |
| 413, |
| views.error_page("The form submission was too large.", self.store.cart_count(session_digest), 413), |
| cookies=cookies, |
| headers={"Connection": "close"}, |
| ) |
| return |
| raw_body = self.rfile.read(content_length) |
|
|
| if path in EXTERNAL_AUTH_API_PATHS: |
| verification = self.external_registration_verification |
| if verification is None: |
| self._send_json( |
| 404, |
| {"ok": False, "error": "not_found"}, |
| cookies=cookies, |
| ) |
| return |
| if not self._auth_post_origin_is_safe(): |
| self._send_json( |
| 403, |
| {"ok": False, "error": "forbidden"}, |
| cookies=cookies, |
| ) |
| return |
| expected_fields = ( |
| frozenset({"email"}) |
| if path == AUTH_SEND_CODE_PATH |
| else frozenset({"email", "code"}) |
| ) |
| fields = ( |
| self._json_fields(raw_body, expected_fields) |
| if not request.query |
| else None |
| ) |
| email = valid_account_email((fields or {}).get("email", "")) |
| code = (fields or {}).get("code", "") |
| if ( |
| fields is None |
| or email is None |
| or ( |
| path == AUTH_VERIFY_CODE_PATH |
| and re.fullmatch(r"[0-9]{6}", code) is None |
| ) |
| ): |
| self._send_json( |
| 400, |
| {"ok": False, "error": "invalid_request"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| try: |
| if path == AUTH_SEND_CODE_PATH: |
| |
| |
| if not self.store.account_exists(email): |
| issue = verification.issue( |
| session_digest, |
| email, |
| self._external_client_address(), |
| ) |
| expires_in = issue.expires_in |
| else: |
| expires_in = 5 * 60 |
| self._send_json( |
| 202, |
| {"ok": True, "expires_in": expires_in}, |
| cookies=cookies, |
| ) |
| return |
|
|
| result = verification.verify(session_digest, email, code) |
| except VerificationRateLimited as exc: |
| self._send_json( |
| 429, |
| { |
| "ok": False, |
| "error": "rate_limited", |
| "retry_after": exc.retry_after, |
| }, |
| cookies=cookies, |
| headers={"Retry-After": str(exc.retry_after)}, |
| ) |
| return |
| except VerificationUnavailable: |
| self._send_json( |
| 503, |
| {"ok": False, "error": "verification_unavailable"}, |
| cookies=cookies, |
| headers={"Retry-After": "30"}, |
| ) |
| return |
|
|
| status_codes = { |
| "verified": 200, |
| "invalid": 400, |
| "expired": 410, |
| "locked": 423, |
| } |
| self._send_json( |
| status_codes.get(result, 503), |
| {"ok": result == "verified", "status": result}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == AUTH_SIGNOUT_PATH: |
| if not self._auth_post_origin_is_safe(): |
| self._send(403, b"Forbidden", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self.store.sign_out(session_digest) |
| cookies.append(browser_cookie(SESSION_COOKIE, "", max_age=0)) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in SPECIALTY_POST_PATHS: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| fields = self._form_fields(raw_body) |
| expected_fields = { |
| specialty.GIFT_CARD_PREVIEW_PATH: { |
| "design", |
| "amount", |
| "recipientKind", |
| }, |
| specialty.GIFT_CARD_REDEEM_PATH: {"claimCode"}, |
| specialty.SELL_DRAFT_PATH: { |
| "title", |
| "category", |
| "condition", |
| "price", |
| "quantity", |
| "description", |
| }, |
| specialty.REGISTRY_CREATE_PATH: { |
| "registryType", |
| "ownerName", |
| "registryName", |
| "eventDate", |
| }, |
| }[path] |
| if query or fields is None or set(fields) != expected_fields: |
| self._send_html( |
| 400, |
| views.error_page("Check the fields and try again.", self.store.cart_count(session_digest), 400), |
| cookies=cookies, |
| ) |
| return |
| try: |
| if path == specialty.GIFT_CARD_PREVIEW_PATH: |
| result = specialty.create_gift_card_preview( |
| self.store, |
| session_digest, |
| fields["design"], |
| fields["amount"], |
| fields["recipientKind"], |
| ) |
| location = specialty.GIFT_CARD_PREVIEW_PATH + "?" + urlencode( |
| {"previewID": int(result["preview_id"])} |
| ) |
| elif path == specialty.GIFT_CARD_REDEEM_PATH: |
| specialty.redeem_gift_card( |
| self.store, session_digest, fields["claimCode"] |
| ) |
| location = specialty.GIFT_CARD_BALANCE_PATH + "?" + urlencode( |
| {"status": "not-applied"} |
| ) |
| elif path == specialty.SELL_DRAFT_PATH: |
| result = specialty.save_seller_draft( |
| self.store, session_digest, fields |
| ) |
| location = specialty.SELL_DRAFT_PATH + "?" + urlencode( |
| {"draftID": int(result["draft_id"])} |
| ) |
| else: |
| result = specialty.create_registry( |
| self.store, session_digest, fields |
| ) |
| location = specialty.REGISTRY_DETAIL_PATH + "?" + urlencode( |
| {"registryID": int(result["registry_id"])} |
| ) |
| except specialty.SpecialtyValidationError: |
| self._send_html( |
| 400, |
| views.error_page("Check the fields and try again.", self.store.cart_count(session_digest), 400), |
| cookies=cookies, |
| ) |
| return |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
|
|
| if path in AUTH_PATHS: |
| fields = self._form_fields(raw_body) |
| if not self._auth_post_origin_is_safe(): |
| self._send(403, b"Forbidden", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
|
|
| if path == "/ap/signin": |
| if fields is not None and "email" in fields and "password" not in fields: |
| email = valid_account_email(fields["email"]) |
| if email is None: |
| self._send_html( |
| 400, |
| auth_views.signin_page( |
| query, "There was a problem with your sign-in. Please try again." |
| ), |
| cookies=cookies, |
| ) |
| return |
| return_to = auth_views.safe_return_target( |
| {"openid.return_to": [fields.get("openid.return_to", "")]} |
| ) |
| if not self.store.account_exists(email): |
| registration_query = {"email": email} |
| if return_to: |
| registration_query["openid.return_to"] = return_to |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": "/ap/register?" |
| + urlencode(registration_query) |
| }, |
| cookies=cookies, |
| ) |
| return |
| self.store.begin_signin(session_digest, email, return_to) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/ap/signin?stage=password"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if fields is not None and "password" in fields and "email" not in fields: |
| password = fields["password"] |
| if 1 <= len(password) <= 1024: |
| authenticated, return_to = self.store.authenticate_session( |
| session_digest, password |
| ) |
| else: |
| authenticated, return_to = False, None |
| if authenticated: |
| self._rotate_authenticated_session(session_digest, cookies) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": return_to or "/"}, |
| cookies=cookies, |
| ) |
| return |
| self._send_html( |
| 401, |
| auth_views.signin_page( |
| {"stage": ["password"]}, |
| "Your email or password is incorrect.", |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| self._send_html( |
| 400, |
| auth_views.signin_page( |
| query, "There was a problem with your sign-in. Please try again." |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == "/ap/register": |
| return_to = auth_views.safe_return_target( |
| {"openid.return_to": [(fields or {}).get("openid.return_to", "")]} |
| ) |
| email = valid_account_email((fields or {}).get("email", "")) |
| display_name = clean_display_name((fields or {}).get("customerName", "")) |
| password = (fields or {}).get("password", "") |
| password_check = (fields or {}).get("passwordCheck", "") |
| passwords_mismatch = password != password_check |
| expected_registration_fields = { |
| "customerName", |
| "email", |
| "password", |
| "passwordCheck", |
| } |
| supplied_registration_fields = ( |
| frozenset(fields) if fields is not None else frozenset() |
| ) |
| valid = bool( |
| fields is not None |
| and supplied_registration_fields |
| in { |
| frozenset(expected_registration_fields), |
| frozenset( |
| {*expected_registration_fields, "openid.return_to"} |
| ), |
| } |
| and email is not None |
| and display_name is not None |
| and 6 <= len(password) <= 1024 |
| and password == password_check |
| ) |
| external_verification = ( |
| self.external_registration_verification |
| ) |
| if external_verification is not None: |
| verified_ticket = False |
| if valid: |
| try: |
| verified_ticket = ( |
| external_verification.consume_verified( |
| session_digest, email or "" |
| ) |
| ) |
| except VerificationUnavailable: |
| self._send_html( |
| 503, |
| auth_views.register_page( |
| query, |
| "Email verification is temporarily unavailable. Please try again.", |
| external_verification=True, |
| ), |
| cookies=cookies, |
| headers={"Retry-After": "30"}, |
| ) |
| return |
| created = bool( |
| valid |
| and verified_ticket |
| and self.store.create_externally_verified_account( |
| session_digest, |
| email or "", |
| display_name or "", |
| password, |
| ) |
| ) |
| if created: |
| self._rotate_authenticated_session( |
| session_digest, cookies |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": return_to or "/"}, |
| cookies=cookies, |
| ) |
| return |
| page_query: dict[str, list[str]] = {} |
| if return_to: |
| page_query["openid.return_to"] = [return_to] |
| if email is not None: |
| page_query["email"] = [email] |
| self._send_html( |
| 400, |
| auth_views.register_page( |
| page_query, |
| ( |
| "Passwords do not match." |
| if passwords_mismatch |
| else ( |
| "Verify this email address, then check your " |
| "details and try again." |
| ) |
| ), |
| external_verification=True, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| pending = bool( |
| valid |
| and self.store.begin_registration( |
| session_digest, |
| email or "", |
| display_name or "", |
| password, |
| return_to, |
| mail_mode=self._mail_mode(), |
| ) |
| ) |
| if pending: |
| self._dispatch_mail( |
| self.store.registration_delivery(session_digest) |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/ap/cvf/verify?purpose=registration"}, |
| cookies=cookies, |
| ) |
| return |
| page_query: dict[str, list[str]] = {} |
| if return_to: |
| page_query["openid.return_to"] = [return_to] |
| if email is not None and not valid: |
| page_query["email"] = [email] |
| self._send_html( |
| 400, |
| auth_views.register_page( |
| page_query, |
| ( |
| "Passwords do not match." |
| if passwords_mismatch |
| else ( |
| "We couldn't create your account. " |
| "Check your details and try again." |
| ) |
| ), |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == "/ap/cvf/verify": |
| purpose_values = query.get("purpose", []) |
| if len(purpose_values) > 1 or ( |
| purpose_values |
| and purpose_values[0] not in {"registration", "password-reset"} |
| ): |
| self._send( |
| 400, |
| b"Malformed verification purpose", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| purpose = purpose_values[0] if purpose_values else "registration" |
| purpose_query = {"purpose": [purpose]} |
| delivery_mode = ( |
| "SMTP" if self.smtp_config is not None else "LOCAL_ONLY" |
| ) |
|
|
| if purpose == "password-reset": |
| if fields == {"action": "retry-delivery"}: |
| pending_reset = self.store.pending_password_reset( |
| session_digest |
| ) |
| queued = bool( |
| self.smtp_config is not None |
| and pending_reset is not None |
| and pending_reset.get("verified") |
| and self.store.retry_password_reset_mail( |
| session_digest |
| ) |
| ) |
| delivery = ( |
| self.store.password_reset_delivery(session_digest) |
| if queued |
| else None |
| ) |
| |
| |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": "/ap/cvf/verify?purpose=password-reset" |
| }, |
| cookies=cookies, |
| ) |
| self._dispatch_mail(delivery) |
| return |
| if fields == {"action": "resend"}: |
| queued = self.store.resend_password_reset_code( |
| session_digest, mail_mode=self._mail_mode() |
| ) |
| delivery = ( |
| self.store.password_reset_delivery(session_digest) |
| if queued |
| else None |
| ) |
| |
| |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": "/ap/cvf/verify?purpose=password-reset" |
| }, |
| cookies=cookies, |
| ) |
| self._dispatch_mail(delivery) |
| return |
|
|
| code = (fields or {}).get("code", "").strip() |
| if set(fields or {}) != {"code"} or not re.fullmatch( |
| r"[0-9]{6}", code |
| ): |
| reset_result = "invalid" |
| else: |
| reset_result = self.store.verify_password_reset_code( |
| session_digest, code |
| ) |
| if reset_result == "verified": |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": "/ap/forgotpassword?stage=reset-password" |
| }, |
| cookies=cookies, |
| ) |
| return |
| reset_errors = { |
| "invalid": "The verification code you entered is not valid.", |
| "expired": "That verification code has expired. Request a new code.", |
| "locked": "Too many incorrect attempts. Request a new code.", |
| "missing": "Start password assistance again to request a new code.", |
| "used": "That verification code has already been used.", |
| } |
| self._send_html( |
| 410 if reset_result == "expired" else 400, |
| auth_views.verification_page( |
| purpose_query, |
| error=reset_errors.get( |
| reset_result, |
| "We couldn't verify that code. Try again.", |
| ), |
| mail_delivery_mode=delivery_mode, |
| mail_delivery=self._auth_mail_status( |
| session_digest, purpose |
| ), |
| local_inbox_url=self.local_inbox_url, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if fields == {"action": "retry-delivery"}: |
| queued = bool( |
| self.smtp_config is not None |
| and self.store.retry_registration_mail(session_digest) |
| ) |
| if queued: |
| self._dispatch_mail( |
| self.store.registration_delivery(session_digest) |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/ap/cvf/verify?purpose=registration"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if fields == {"action": "resend"}: |
| if self.store.resend_registration_code( |
| session_digest, mail_mode=self._mail_mode() |
| ): |
| self._dispatch_mail( |
| self.store.registration_delivery(session_digest) |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": "/ap/cvf/verify?purpose=registration"}, |
| cookies=cookies, |
| ) |
| return |
| self._send_html( |
| 400, |
| auth_views.verification_page( |
| purpose_query, |
| error="Start account creation again to request a new code.", |
| mail_delivery_mode=delivery_mode, |
| mail_delivery=self._auth_mail_status( |
| session_digest, purpose |
| ), |
| local_inbox_url=self.local_inbox_url, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| code = (fields or {}).get("code", "").strip() |
| if set(fields or {}) != {"code"} or not re.fullmatch(r"[0-9]{6}", code): |
| result, return_to = "invalid", None |
| else: |
| result, return_to = self.store.verify_registration_code( |
| session_digest, code |
| ) |
| if result == "verified": |
| self._rotate_authenticated_session(session_digest, cookies) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": return_to or "/"}, |
| cookies=cookies, |
| ) |
| return |
|
|
| pending_registration = self.store.pending_registration(session_digest) |
| error_messages = { |
| "invalid": "The verification code you entered is not valid.", |
| "expired": "That verification code has expired. Request a new code.", |
| "locked": "Too many incorrect attempts. Request a new code.", |
| "missing": "Start account creation again to request a new code.", |
| "duplicate": "We couldn't create your account. Sign in or try again.", |
| } |
| status = 410 if result == "expired" else 400 |
| self._send_html( |
| status, |
| auth_views.verification_page( |
| purpose_query, |
| masked_destination=(pending_registration or {}).get( |
| "masked_email" |
| ), |
| error=error_messages.get( |
| result, "We couldn't verify that code. Try again." |
| ), |
| mail_delivery_mode=delivery_mode, |
| mail_delivery=self._auth_mail_status( |
| session_digest, purpose |
| ), |
| local_inbox_url=self.local_inbox_url, |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == "/ap/forgotpassword": |
| if fields is not None and "email" in fields and not { |
| "password", |
| "passwordCheck", |
| }.intersection(fields): |
| if set(fields) not in ( |
| {"email"}, |
| {"email", "openid.return_to"}, |
| ): |
| email = None |
| else: |
| email = valid_account_email(fields.get("email", "")) |
| if email is None: |
| self._send_html( |
| 400, |
| auth_views.forgot_password_page( |
| {}, |
| "We couldn't process that request. Check the email address and try again.", |
| ), |
| cookies=cookies, |
| ) |
| return |
| return_to = auth_views.safe_return_target( |
| { |
| "openid.return_to": [ |
| fields.get("openid.return_to", "") |
| ] |
| } |
| ) |
| self.store.begin_password_reset( |
| session_digest, |
| email, |
| return_to, |
| mail_mode=self._mail_mode(), |
| ) |
| delivery = self.store.password_reset_delivery(session_digest) |
| |
| |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": "/ap/cvf/verify?purpose=password-reset" |
| }, |
| cookies=cookies, |
| ) |
| self._dispatch_mail(delivery) |
| return |
|
|
| if fields is not None and set(fields) == { |
| "password", |
| "passwordCheck", |
| }: |
| password = fields["password"] |
| password_check = fields["passwordCheck"] |
| if not ( |
| 6 <= len(password) <= 1024 and password == password_check |
| ): |
| self._send_html( |
| 400, |
| auth_views.forgot_password_page( |
| {"stage": ["reset-password"]}, |
| "Passwords must match and contain at least 6 characters.", |
| ), |
| cookies=cookies, |
| ) |
| return |
| reset_result, return_to = self.store.complete_password_reset( |
| session_digest, password |
| ) |
| if reset_result == "reset": |
| self._rotate_authenticated_session(session_digest, cookies) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": return_to or "/"}, |
| cookies=cookies, |
| ) |
| return |
| self._send_html( |
| 410 if reset_result == "expired" else 400, |
| auth_views.forgot_password_page( |
| {"stage": ["reset-password"]}, |
| "This password reset is no longer valid. Start again.", |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| self._send_html( |
| 400, |
| auth_views.forgot_password_page( |
| {}, "We couldn't process that password assistance request." |
| ), |
| cookies=cookies, |
| ) |
| return |
|
|
| self._send( |
| 400, |
| b"Malformed authentication request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in WISHLIST_POST_PATHS: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if query: |
| self._send( |
| 400, |
| b"Malformed Wishlist request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if self.store.account_for_session(session_digest) is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": wishlist_views.WISHLIST_INDEX_PATH} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| fields = self._form_fields(raw_body) |
| valid_shape = False |
| selected_options: dict[str, str] = {} |
| if fields is not None: |
| expected_fields = { |
| wishlist_views.WISHLIST_CREATE_PATH: {"listName"}, |
| wishlist_views.WISHLIST_RENAME_PATH: { |
| "listID", |
| "listName", |
| }, |
| wishlist_views.WISHLIST_DELETE_PATH: {"listID"}, |
| wishlist_views.WISHLIST_REMOVE_ITEM_PATH: { |
| "listID", |
| "itemID", |
| }, |
| wishlist_views.WISHLIST_MOVE_TO_CART_PATH: { |
| "listID", |
| "itemID", |
| "quantity", |
| }, |
| } |
| if path == wishlist_views.WISHLIST_ADD_ITEM_PATH: |
| base_fields = {"listID", "ASIN"} |
| option_fields = { |
| name |
| for name in fields |
| if name.startswith("option.") |
| and name.removeprefix("option.") |
| } |
| valid_shape = bool( |
| base_fields.issubset(fields) |
| and set(fields) == base_fields | option_fields |
| ) |
| if valid_shape: |
| selected_options = { |
| name.removeprefix("option."): fields[name] |
| for name in option_fields |
| } |
| else: |
| valid_shape = set(fields) == expected_fields[path] |
| if ( |
| path == wishlist_views.WISHLIST_MOVE_TO_CART_PATH |
| and fields.get("quantity") != "1" |
| ): |
| valid_shape = False |
| if not valid_shape or fields is None: |
| self._send( |
| 400, |
| b"Malformed Wishlist request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
|
|
| try: |
| if path == wishlist_views.WISHLIST_CREATE_PATH: |
| created_list = wishlist.create_list( |
| self.store, session_digest, fields["listName"] |
| ) |
| location = wishlist_views.WISHLIST_INDEX_PATH + "?" + urlencode( |
| { |
| "listID": created_list["list_id"], |
| "status": "created", |
| } |
| ) |
| elif path == wishlist_views.WISHLIST_RENAME_PATH: |
| renamed_list = wishlist.rename_list( |
| self.store, |
| session_digest, |
| fields["listID"], |
| fields["listName"], |
| ) |
| location = wishlist_views.WISHLIST_INDEX_PATH + "?" + urlencode( |
| { |
| "listID": renamed_list["list_id"], |
| "status": "renamed", |
| } |
| ) |
| elif path == wishlist_views.WISHLIST_DELETE_PATH: |
| wishlist.delete_list( |
| self.store, session_digest, fields["listID"] |
| ) |
| location = wishlist_views.WISHLIST_INDEX_PATH + "?" + urlencode( |
| {"status": "deleted"} |
| ) |
| elif path == wishlist_views.WISHLIST_ADD_ITEM_PATH: |
| result = wishlist.add_item( |
| self.store, |
| session_digest, |
| fields["listID"], |
| fields["ASIN"], |
| selected_options, |
| ) |
| location = wishlist_views.WISHLIST_INDEX_PATH + "?" + urlencode( |
| { |
| "listID": fields["listID"], |
| "status": ( |
| "added" if result["created"] else "already-added" |
| ), |
| } |
| ) |
| elif path == wishlist_views.WISHLIST_REMOVE_ITEM_PATH: |
| wishlist.remove_item( |
| self.store, |
| session_digest, |
| fields["listID"], |
| fields["itemID"], |
| ) |
| location = wishlist_views.WISHLIST_INDEX_PATH + "?" + urlencode( |
| {"listID": fields["listID"], "status": "removed"} |
| ) |
| else: |
| item = wishlist.item_for_move_to_cart( |
| self.store, |
| session_digest, |
| fields["listID"], |
| fields["itemID"], |
| ) |
| self.store.add_cart_item( |
| session_digest, |
| item["asin"], |
| fields["quantity"], |
| item["selected_options"], |
| ) |
| try: |
| wishlist.remove_item( |
| self.store, |
| session_digest, |
| item["list_id"], |
| item["item_id"], |
| ) |
| except wishlist.WishlistNotFound: |
| |
| |
| |
| pass |
| location = "/gp/cart/view.html" |
| except wishlist.WishlistAuthenticationRequired: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": wishlist_views.WISHLIST_INDEX_PATH} |
| ) |
| except wishlist.WishlistNotFound: |
| self._send_html( |
| 404, |
| views.not_found_page(self.store.cart_count(session_digest)), |
| cookies=cookies, |
| ) |
| return |
| except wishlist.WishlistValidationError as exc: |
| self._send_html( |
| 400, |
| views.error_page( |
| str(exc), self.store.cart_count(session_digest), 400 |
| ), |
| cookies=cookies, |
| ) |
| return |
| except (wishlist.WishlistConflict, ContractError) as exc: |
| self._send_html( |
| 409, |
| views.error_page( |
| str(exc), self.store.cart_count(session_digest), 409 |
| ), |
| cookies=cookies, |
| ) |
| return |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
|
|
| if path in ADDRESS_BOOK_POST_PATHS: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| account = self.store.account_for_session(session_digest) |
| if account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": ADDRESS_BOOK_PATH} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| fields = self._form_fields(raw_body) |
| make_default = False |
| address: dict[str, str] | None = None |
| if path == ADDRESS_CREATE_PATH: |
| allowed = ADDRESS_FORM_NAMES | {"makeDefault"} |
| valid_shape = bool( |
| fields is not None |
| and ADDRESS_FORM_NAMES.issubset(fields) |
| and set(fields).issubset(allowed) |
| ) |
| elif path == ADDRESS_UPDATE_PATH: |
| allowed = ADDRESS_FORM_NAMES | { |
| "addressId", |
| "addressRevision", |
| "makeDefault", |
| } |
| valid_shape = bool( |
| fields is not None |
| and (ADDRESS_FORM_NAMES | {"addressId", "addressRevision"}).issubset(fields) |
| and set(fields).issubset(allowed) |
| ) |
| else: |
| valid_shape = bool( |
| fields is not None |
| and set(fields) == {"addressId", "addressRevision"} |
| ) |
| if not valid_shape or ( |
| fields is not None |
| and "makeDefault" in fields |
| and fields["makeDefault"] != "1" |
| ): |
| self._send( |
| 400, |
| b"Malformed address request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| assert fields is not None |
| if path in {ADDRESS_CREATE_PATH, ADDRESS_UPDATE_PATH}: |
| address = normalized_address_fields(fields) |
| if address is None: |
| self._send( |
| 400, |
| b"Invalid address", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| make_default = fields.get("makeDefault") == "1" |
| try: |
| if path == ADDRESS_CREATE_PATH: |
| assert address is not None |
| self.store.create_address( |
| session_digest, |
| address, |
| make_default=make_default, |
| ) |
| status_label = "added" |
| elif path == ADDRESS_UPDATE_PATH: |
| assert address is not None |
| self.store.update_address( |
| session_digest, |
| fields["addressId"], |
| fields["addressRevision"], |
| address, |
| make_default=make_default, |
| ) |
| status_label = "updated" |
| elif path == ADDRESS_DEFAULT_PATH: |
| self.store.set_default_address( |
| session_digest, |
| fields["addressId"], |
| fields["addressRevision"], |
| ) |
| status_label = "default" |
| else: |
| self.store.delete_address( |
| session_digest, |
| fields["addressId"], |
| fields["addressRevision"], |
| ) |
| status_label = "deleted" |
| except AddressNotFound: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except (AddressRevisionConflict, AddressInUse) as exc: |
| message = ( |
| "This address is currently selected by an active checkout. Choose another checkout address before deleting it." |
| if isinstance(exc, AddressInUse) |
| else "This address changed in another request. Review the latest version and try again." |
| ) |
| self._send_html( |
| 409, |
| views.address_book_page( |
| self.store.addresses_for_session(session_digest), |
| self.store.cart_count(session_digest), |
| str(account["display_name"]), |
| error=message, |
| ), |
| cookies=cookies, |
| ) |
| return |
| except ContractError: |
| self._send( |
| 400, |
| b"Invalid address request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| self._send( |
| 303, |
| b"", |
| headers={ |
| "Location": ADDRESS_BOOK_PATH |
| + "?" |
| + urlencode({"status": status_label}) |
| }, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path in {ORDER_CANCEL_PATH, RETURN_CREATE_PATH}: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| account = self.store.account_for_session(session_digest) |
| if account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": "/gp/css/order-history"} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| fields = self._form_fields(raw_body) |
| required = ( |
| {"orderID", "idempotencyKey", "actionToken"} |
| if path == ORDER_CANCEL_PATH |
| else { |
| "orderID", |
| "reasonCode", |
| "customerNote", |
| "idempotencyKey", |
| "actionToken", |
| } |
| ) |
| if ( |
| fields is None |
| or set(fields) != required |
| or re.fullmatch(r"[1-9][0-9]{0,18}", fields.get("orderID", "")) |
| is None |
| or re.fullmatch( |
| r"[A-Za-z0-9_-]{20,128}", fields.get("idempotencyKey", "") |
| ) |
| is None |
| or re.fullmatch(r"[0-9a-f]{64}", fields.get("actionToken", "")) |
| is None |
| ): |
| self._send( |
| 400, |
| b"Malformed order action", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| if path == ORDER_CANCEL_PATH: |
| order = self.store.cancel_order( |
| session_digest, |
| fields["orderID"], |
| fields["idempotencyKey"], |
| fields["actionToken"], |
| ) |
| location = ORDER_DETAIL_PATH + "?" + urlencode( |
| {"orderID": order["order_id"]} |
| ) |
| else: |
| order = self.store.create_return_request( |
| session_digest, |
| fields["orderID"], |
| fields["reasonCode"], |
| fields["customerNote"], |
| fields["idempotencyKey"], |
| fields["actionToken"], |
| ) |
| request_payload = order.get("return_request") |
| if not isinstance(request_payload, dict): |
| raise OrderStateConflict("return request was not created") |
| location = RETURN_DETAIL_PATH + "?" + urlencode( |
| {"returnID": request_payload["return_request_id"]} |
| ) |
| except OrderActionTokenInvalid: |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except OrderNotFound: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except OrderStateConflict as exc: |
| self._send_html( |
| 409, |
| views.error_page(str(exc), self.store.cart_count(session_digest), 409), |
| cookies=cookies, |
| ) |
| return |
| except ContractError as exc: |
| self._send( |
| 400, |
| str(exc).encode("utf-8"), |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
|
|
| review_post_match = PRODUCT_REVIEWS_ROUTE.fullmatch(path) |
| helpful_post_match = PRODUCT_REVIEW_HELPFUL_ROUTE.fullmatch(path) |
| if review_post_match or helpful_post_match: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| asin = (review_post_match or helpful_post_match).group(1) |
| product = product_for_pdp(self.store, asin) |
| source_scope = review_product_source_scope(self.store, asin) |
| if product is None or source_scope is None: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| self.store.register_review_product(asin, source_scope) |
| fields = self._form_fields(raw_body) |
| destination = f"/product-reviews/{asin}#customerReviews" |
|
|
| if review_post_match: |
| if self.store.account_for_session(session_digest) is None: |
| signin_location = "/ap/signin?" + urlencode( |
| {"openid.return_to": f"/product-reviews/{asin}#reviewComposer"} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": signin_location}, |
| cookies=cookies, |
| ) |
| return |
| if ( |
| fields is None |
| or set(fields) != {"rating", "headline", "body"} |
| or re.fullmatch(r"[1-5]", fields.get("rating", "")) is None |
| ): |
| self._send( |
| 400, |
| b"Malformed review request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| self.store.upsert_review( |
| session_digest, |
| asin, |
| int(fields["rating"]), |
| fields["headline"], |
| fields["body"], |
| ) |
| except ReviewAuthenticationRequired: |
| signin_location = "/ap/signin?" + urlencode( |
| {"openid.return_to": f"/product-reviews/{asin}#reviewComposer"} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": signin_location}, |
| cookies=cookies, |
| ) |
| return |
| except ReviewValidationError as exc: |
| self._send( |
| 400, |
| str(exc).encode("utf-8"), |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except ReviewPermissionDenied: |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except ReviewNotFound: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| else: |
| if ( |
| fields is None |
| or set(fields) != {"reviewId"} |
| or re.fullmatch(r"[1-9][0-9]*", fields.get("reviewId", "")) is None |
| ): |
| self._send( |
| 400, |
| b"Malformed helpful request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| self.store.toggle_review_helpful( |
| session_digest, asin, fields["reviewId"] |
| ) |
| except ReviewValidationError as exc: |
| self._send( |
| 400, |
| str(exc).encode("utf-8"), |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except ReviewPermissionDenied: |
| self._send( |
| 403, |
| b"You cannot mark your own review as helpful.", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| except ReviewNotFound: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
|
|
| self._send( |
| 303, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == ORDER_EMAIL_RETRY_PATH: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| fields = self._form_fields(raw_body) |
| if ( |
| query |
| or fields is None |
| or set(fields) != {"orderID"} |
| or re.fullmatch(r"[1-9][0-9]*", fields["orderID"]) is None |
| ): |
| self._send( |
| 400, |
| b"Malformed order email retry request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if self.store.account_for_session(session_digest) is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": ORDER_DETAIL_PATH} |
| ) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
| order_id = fields["orderID"] |
| if self.store.order_for_session(session_digest, order_id) is None: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if ( |
| self.smtp_config is not None |
| and self.store.retry_order_mail(session_digest, order_id) |
| ): |
| self._dispatch_mail(self.store.order_mail_delivery(order_id)) |
| location = ORDER_DETAIL_PATH + "?" + urlencode({"orderID": order_id}) |
| self._send( |
| 303, b"", headers={"Location": location}, cookies=cookies |
| ) |
| return |
|
|
| checkout_post_paths = { |
| CHECKOUT_START_PATH, |
| CHECKOUT_ADDRESS_PATH, |
| CHECKOUT_DELIVERY_PATH, |
| CHECKOUT_PAYMENT_PATH, |
| PLACE_ORDER_PATH, |
| STRIPE_CHECKOUT_PATH, |
| STRIPE_CANCEL_PATH, |
| } |
| if path in checkout_post_paths: |
| |
| if path == CHECKOUT_START_PATH and raw_body: |
| self.store.record_rejected_post( |
| session_digest, |
| path, |
| self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower(), |
| raw_body, |
| ) |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if not self._auth_post_origin_is_safe(): |
| self._send(403, b"Forbidden", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| account = self.store.account_for_session(session_digest) |
| if account is None: |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": CHECKOUT_ADDRESS_PATH} |
| ) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
| fields = self._form_fields(raw_body) |
|
|
| if path == STRIPE_CHECKOUT_PATH: |
| if ( |
| not self.payment_config.stripe_enabled |
| or self.stripe_gateway is None |
| ): |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if ( |
| fields is None |
| or set(fields) != {"idempotencyKey"} |
| or re.fullmatch( |
| r"[A-Za-z0-9_-]{20,160}", |
| fields.get("idempotencyKey", ""), |
| ) |
| is None |
| ): |
| self._send( |
| 400, |
| b"Malformed Stripe checkout request", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| current = self.store.reconcile_checkout(session_digest) |
| if ( |
| current is None |
| or str(current.get("idempotency_key") or "") |
| != fields["idempotencyKey"] |
| ): |
| self._send( |
| 409, |
| b"Checkout state conflict", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| preparation = self.store.prepare_stripe_checkout( |
| session_digest |
| ) |
| success_url, cancel_url = self._stripe_return_urls() |
| provider_session = ( |
| self.stripe_gateway.create_checkout_session( |
| preparation, |
| success_url=success_url, |
| cancel_url=cancel_url, |
| ) |
| ) |
| self.store.attach_stripe_checkout_session( |
| session_digest, |
| str(preparation["checkout_token"]), |
| provider_session, |
| ) |
| location = str(provider_session.get("url") or "") |
| parsed_location = urlsplit(location) |
| if ( |
| parsed_location.scheme != "https" |
| or parsed_location.hostname != "checkout.stripe.com" |
| or parsed_location.username |
| or parsed_location.password |
| or parsed_location.port is not None |
| or parsed_location.fragment |
| ): |
| raise ContractError( |
| "Stripe returned an invalid checkout URL" |
| ) |
| except StripeAPIError: |
| self._send_html( |
| 503, |
| views.error_page( |
| "Stripe test Checkout is temporarily unavailable. " |
| "Your cart and frozen checkout were kept; return to " |
| "review and retry.", |
| self.store.cart_count(session_digest), |
| 503, |
| ), |
| cookies=cookies, |
| ) |
| return |
| except ContractError as exc: |
| self._send_html( |
| 409, |
| views.error_page( |
| str(exc), |
| self.store.cart_count(session_digest), |
| 409, |
| ), |
| cookies=cookies, |
| ) |
| return |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == STRIPE_CANCEL_PATH: |
| if ( |
| not self.payment_config.stripe_enabled |
| or self.stripe_gateway is None |
| or fields is None |
| or set(fields) != {"sessionID"} |
| ): |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| session_id = fields["sessionID"] |
| mapping = ( |
| self.store.stripe_checkout_for_session( |
| session_digest, session_id |
| ) |
| if STRIPE_PROVIDER_SESSION_PATTERN.fullmatch(session_id) |
| else None |
| ) |
| if mapping is None: |
| self._send( |
| 404, |
| b"Not Found", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| provider_session = ( |
| self.stripe_gateway.retrieve_checkout_session( |
| session_id |
| ) |
| ) |
| if ( |
| str( |
| provider_session.get("payment_status") or "" |
| ) |
| == "paid" |
| ): |
| order = self.store.confirm_stripe_return( |
| session_digest, |
| session_id, |
| provider_session, |
| mail_mode=self._mail_mode(), |
| ) |
| if order is None: |
| raise ContractError( |
| "paid Stripe Session was not fulfilled" |
| ) |
| self._dispatch_mail( |
| self.store.order_mail_delivery(order["order_id"]) |
| ) |
| location = ORDER_DETAIL_PATH + "?" + urlencode( |
| {"orderID": order["order_id"]} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| if str(provider_session.get("status") or "") != "expired": |
| provider_session = ( |
| self.stripe_gateway.expire_checkout_session( |
| session_id |
| ) |
| ) |
| self.store.cancel_stripe_checkout( |
| session_digest, |
| session_id, |
| provider_session, |
| ) |
| except StripeAPIError: |
| self._send_html( |
| 503, |
| views.stripe_payment_status_page( |
| mapping, |
| self.store.cart_count(session_digest), |
| str(account.get("display_name") or "Customer"), |
| session_id=session_id, |
| state="unavailable", |
| cancelled=True, |
| ), |
| cookies=cookies, |
| ) |
| return |
| except ContractError: |
| self._send( |
| 409, |
| b"Stripe checkout state conflict", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| destination = CHECKOUT_PAYMENT_PATH + "?" + urlencode( |
| {"notice": "payment-cancelled"} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == CHECKOUT_START_PATH: |
| if fields != {}: |
| self._send(400, b"Malformed checkout request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| try: |
| checkout = self.store.start_checkout(session_digest) |
| except ContractError: |
| self._send_html( |
| 409, |
| views.error_page( |
| "Your cart is empty or checkout cannot be started.", |
| self.store.cart_count(session_digest), |
| 409, |
| ), |
| cookies=cookies, |
| ) |
| return |
| destination = CHECKOUT_ADDRESS_PATH |
| if ( |
| checkout.get("reconciliation_reason") == "cart-changed" |
| and checkout.get("status") == "DELIVERY_SELECTED" |
| ): |
| destination = CHECKOUT_PAYMENT_PATH + "?" + urlencode( |
| {"notice": "cart-changed"} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if path == CHECKOUT_ADDRESS_PATH: |
| if fields is not None and set(fields) == {"addressSelection"}: |
| selection_match = re.fullmatch( |
| r"([1-9][0-9]*):([1-9][0-9]*)", |
| fields["addressSelection"], |
| ) |
| if selection_match is None: |
| self._send( |
| 400, |
| b"Malformed address selection", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| try: |
| self.store.select_checkout_address( |
| session_digest, |
| selection_match.group(1), |
| selection_match.group(2), |
| ) |
| except ContractError: |
| self._send( |
| 409, |
| b"Checkout address conflict", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| self._send( |
| 303, |
| b"", |
| headers={"Location": CHECKOUT_DELIVERY_PATH}, |
| cookies=cookies, |
| ) |
| return |
| allowed = ADDRESS_FORM_NAMES | {"makeDefault"} |
| if ( |
| fields is None |
| or not ADDRESS_FORM_NAMES.issubset(fields) |
| or not set(fields).issubset(allowed) |
| or ( |
| "makeDefault" in fields |
| and fields["makeDefault"] != "1" |
| ) |
| ): |
| self._send(400, b"Malformed address", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| address = normalized_address_fields(fields) |
| if address is None: |
| self._send(400, b"Invalid address", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| try: |
| self.store.save_checkout_address( |
| session_digest, |
| address, |
| make_default=fields.get("makeDefault") == "1", |
| ) |
| except ContractError: |
| self._send(409, b"Checkout state conflict", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self._send(303, b"", headers={"Location": CHECKOUT_DELIVERY_PATH}, cookies=cookies) |
| return |
|
|
| if path == CHECKOUT_DELIVERY_PATH: |
| if fields is None or set(fields) != {"deliveryOption"}: |
| self._send(400, b"Malformed delivery option", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| try: |
| self.store.select_delivery(session_digest, fields["deliveryOption"]) |
| except ContractError: |
| self._send(409, b"Checkout state conflict", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self._send(303, b"", headers={"Location": CHECKOUT_PAYMENT_PATH}, cookies=cookies) |
| return |
|
|
| if path == CHECKOUT_PAYMENT_PATH: |
| if fields is None or set(fields) != {"paymentMethod"}: |
| self._send(400, b"Malformed payment method", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| try: |
| if self.payment_config.mode == PAYMENT_MODE_STRIPE_TEST: |
| if fields["paymentMethod"] != "stripe-test": |
| raise ContractError( |
| "Stripe test Checkout is required" |
| ) |
| checkout = self.store.prepare_stripe_review( |
| session_digest |
| ) |
| else: |
| checkout = self.store.select_test_payment( |
| session_digest, fields["paymentMethod"] |
| ) |
| except ContractError: |
| self._send(409, b"Checkout state conflict", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| payment_attempt = checkout.get("payment_attempt") |
| destination = ( |
| CHECKOUT_PAYMENT_PATH |
| + "?" |
| + urlencode({"notice": "payment-declined"}) |
| if isinstance(payment_attempt, dict) |
| and payment_attempt.get("status") == "DECLINED" |
| else CHECKOUT_START_PATH |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
|
|
| if ( |
| self.payment_config.mode == PAYMENT_MODE_STRIPE_TEST |
| and path == PLACE_ORDER_PATH |
| ): |
| self._send( |
| 409, |
| b"Stripe test payment must be confirmed before ordering", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| if fields is None or set(fields) != {"idempotencyKey"} or not re.fullmatch( |
| r"[A-Za-z0-9_-]{20,160}", fields.get("idempotencyKey", "") |
| ): |
| self._send(400, b"Malformed place-order request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| try: |
| order = self.store.place_order( |
| session_digest, |
| fields["idempotencyKey"], |
| mail_mode=self._mail_mode(), |
| ) |
| except CheckoutReconciliationRequired as exc: |
| destination = ( |
| CHECKOUT_ADDRESS_PATH |
| if exc.reason == "unsupported-delivery-country" |
| else CHECKOUT_PAYMENT_PATH |
| ) + "?" + urlencode({"notice": exc.reason}) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": destination}, |
| cookies=cookies, |
| ) |
| return |
| except ContractError: |
| self._send(409, b"Checkout state conflict", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self._dispatch_mail( |
| self.store.order_mail_delivery(order["order_id"]) |
| ) |
| location = ORDER_DETAIL_PATH + "?" + urlencode({"orderID": order["order_id"]}) |
| self._send(303, b"", headers={"Location": location}, cookies=cookies) |
| return |
|
|
| if path in COMPARE_MUTATION_PATHS: |
| if not self._auth_post_origin_is_safe(): |
| self._send(403, b"Forbidden", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| fields = self._form_fields(raw_body) |
| if path == "/gp/compare/clear": |
| if fields != {}: |
| self._send(400, b"Malformed compare request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self.store.clear_compare(session_digest) |
| self._send(303, b"", headers={"Location": COMPARE_PATH}, cookies=cookies) |
| return |
| if path == "/gp/compare/remove": |
| if fields is None or set(fields) != {"compareLineID"}: |
| self._send(400, b"Malformed compare request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| compare_line_id = fields["compareLineID"] |
| if COMPARE_LINE_ID_PATTERN.fullmatch(compare_line_id) is None: |
| self._send(400, b"Malformed compare request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if not self.store.remove_compare(session_digest, compare_line_id): |
| self._send(409, b"Compare item not found", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| self._send(303, b"", headers={"Location": COMPARE_PATH}, cookies=cookies) |
| return |
|
|
| option_field_names = { |
| name for name in fields or {} if name.startswith("option.") |
| } |
| if ( |
| fields is None |
| or "ASIN" not in fields |
| or set(fields) != {"ASIN"} | option_field_names |
| or any(not name.removeprefix("option.") for name in option_field_names) |
| ): |
| self._send(400, b"Malformed compare request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| asin = fields["ASIN"] |
| if ASIN_PATTERN.fullmatch(asin) is None: |
| self._send(400, b"Malformed compare request", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if asin not in self.store.compare_eligible_asins(): |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| expected_option_names = { |
| f"option.{group['label']}" |
| for group in self.store.product_option_spec(asin) |
| } |
| if option_field_names and option_field_names != expected_option_names: |
| self._send(400, b"Malformed compare options", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| selected_options = ( |
| { |
| name.removeprefix("option."): fields[name] |
| for name in option_field_names |
| } |
| if option_field_names |
| else None |
| ) |
| try: |
| result = self.store.add_compare( |
| session_digest, asin, selected_options |
| ) |
| except ContractError: |
| self._send(400, b"Invalid compare options", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if result in {"full", "incompatible"}: |
| products = [ |
| compare_product_for_view(self.store, item) |
| for item in self.store.compare_items(session_digest) |
| ] |
| account = self.store.account_for_session(session_digest) |
| name = str(account["display_name"]) if account else None |
| message = ( |
| "You can compare up to four products at a time." |
| if result == "full" |
| else "Choose products from the same product family." |
| ) |
| self._send_html( |
| 409, |
| views.compare_page( |
| products, |
| self.store.cart_count(session_digest), |
| name, |
| message, |
| ), |
| cookies=cookies, |
| ) |
| return |
| self._send(303, b"", headers={"Location": COMPARE_PATH}, cookies=cookies) |
| return |
|
|
| if path in CART_MUTATION_PATHS: |
| if not self._auth_post_origin_is_safe(): |
| self._send(403, b"Forbidden", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if ( |
| path in AUTHENTICATED_CART_MUTATION_PATHS |
| and self.store.account_for_session(session_digest) is None |
| ): |
| self._send( |
| 303, |
| b"", |
| headers={"Location": self._signin_location_for_cart_mutation()}, |
| cookies=cookies, |
| ) |
| return |
| fields = self._form_fields(raw_body) |
| is_product_mutation = path in {BUY_NOW_PATH, "/gp/cart/add.html"} |
| needs_quantity = path in { |
| BUY_NOW_PATH, |
| "/gp/cart/add.html", |
| "/gp/cart/update.html", |
| } |
| if is_product_mutation: |
| base_names = {"ASIN", "quantity"} |
| elif needs_quantity: |
| base_names = {"lineID", "quantity"} |
| else: |
| base_names = {"lineID"} |
| option_field_names = ( |
| {name for name in fields or {} if name.startswith("option.")} |
| if is_product_mutation |
| else set() |
| ) |
| if fields is None or set(fields) != base_names | option_field_names: |
| self._send_html( |
| 400, |
| views.error_page( |
| "The cart request was incomplete or malformed.", |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| asin = "" |
| line_id = "" |
| selected_options: dict[str, str] | None = None |
| if is_product_mutation: |
| asin = fields["ASIN"] |
| if ASIN_PATTERN.fullmatch(asin) is None: |
| self._send_html( |
| 400, |
| views.error_page( |
| "The selected item identifier is invalid.", |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if self.store.commerce_offer(asin) is None: |
| self._send_html( |
| 404, |
| views.error_page( |
| "That item is not currently available in this marketplace.", |
| self.store.cart_count(session_digest), |
| 404, |
| ), |
| cookies=cookies, |
| ) |
| return |
| option_spec = self.store.product_option_spec(asin) |
| expected_option_names = { |
| f"option.{group['label']}" for group in option_spec |
| } |
| if option_field_names and option_field_names != expected_option_names: |
| self._send_html( |
| 400, |
| views.error_page( |
| "Choose one value for every available product option.", |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| selected_options = ( |
| { |
| name.removeprefix("option."): fields[name] |
| for name in option_field_names |
| } |
| if option_field_names |
| else None |
| ) |
| else: |
| line_id = fields["lineID"] |
| if CART_LINE_ID_PATTERN.fullmatch(line_id) is None: |
| self._send_html( |
| 400, |
| views.error_page( |
| "The cart line identity is invalid.", |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| quantity = 1 |
| if needs_quantity: |
| raw_quantity = fields["quantity"] |
| if not re.fullmatch(r"(?:[1-9]|[12][0-9]|30)", raw_quantity): |
| self._send_html( |
| 400, |
| views.error_page( |
| "Choose a quantity from 1 through 30.", |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| quantity = int(raw_quantity) |
| try: |
| buy_now_result: dict[str, Any] | None = None |
| added_line_id: str | None = None |
| if path == BUY_NOW_PATH: |
| buy_now_result = self.store.begin_buy_now( |
| session_digest, |
| asin, |
| quantity, |
| selected_options=selected_options, |
| ) |
| changed = True |
| elif path == "/gp/cart/add.html": |
| changed = bool( |
| self.store.add_cart_item( |
| session_digest, |
| asin, |
| quantity, |
| selected_options=selected_options, |
| ) |
| ) |
| expected_selection = ( |
| selected_options |
| if selected_options is not None |
| else self.store.default_product_options(asin) |
| ) |
| added_line_id = next( |
| ( |
| str(line["line_id"]) |
| for line in self.store.cart(session_digest) |
| if line["asin"] == asin |
| and line.get("selected_options") == expected_selection |
| ), |
| None, |
| ) |
| elif path == "/gp/cart/update.html": |
| changed = self.store.set_cart_quantity( |
| session_digest, line_id, quantity |
| ) |
| elif path == "/gp/cart/delete.html": |
| changed = self.store.delete_cart_item(session_digest, line_id) |
| elif path == "/gp/cart/save-for-later.html": |
| changed = self.store.save_for_later(session_digest, line_id) |
| else: |
| changed = self.store.move_to_cart(session_digest, line_id) |
| except ContractError as exc: |
| message = ( |
| UNAVAILABLE_SELECTION_COPY |
| if str(exc) == UNAVAILABLE_SELECTION_COPY |
| else "That item cannot be added to this local marketplace cart." |
| ) |
| self._send_html( |
| 400, |
| views.error_page( |
| message, |
| self.store.cart_count(session_digest), |
| 400, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if not changed: |
| self._send_html( |
| 409, |
| views.error_page( |
| "That cart item is no longer in the expected state.", |
| self.store.cart_count(session_digest), |
| 409, |
| ), |
| cookies=cookies, |
| ) |
| return |
| if path == BUY_NOW_PATH: |
| if buy_now_result and buy_now_result.get( |
| "requires_authentication" |
| ): |
| location = "/ap/signin?" + urlencode( |
| {"openid.return_to": BUY_NOW_CONTINUE_PATH} |
| ) |
| else: |
| location = CHECKOUT_ADDRESS_PATH |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| location = ( |
| ADD_TO_CART_CONFIRMATION_PATH |
| + "?" |
| + urlencode({"lineID": str(added_line_id)}) |
| if path == "/gp/cart/add.html" and added_line_id is not None |
| else "/gp/cart/view.html" |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
| if path == DELIVERY_PREFERENCE_PATH: |
| if not self._auth_post_origin_is_safe(): |
| self._send( |
| 403, |
| b"Forbidden", |
| content_type="text/plain; charset=utf-8", |
| cookies=cookies, |
| ) |
| return |
| fields = self._form_fields(raw_body) |
| expected_fields = { |
| "dropdown-selection", |
| "glow-destination-type", |
| "glow-validation-token", |
| } |
| |
| |
| |
| |
| |
| accepted = ( |
| not query |
| and fields is not None |
| and set(fields) == expected_fields |
| and fields["glow-destination-type"] == "COUNTRY" |
| and hmac.compare_digest( |
| fields["glow-validation-token"], |
| delivery_location_token(session_digest), |
| ) |
| and self.store.set_delivery_country( |
| session_digest, fields["dropdown-selection"] |
| ) |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": self._delivery_return_location(error=not accepted)}, |
| cookies=cookies, |
| ) |
| return |
| if path.startswith("/ap/"): |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| if path.startswith("/__bench/") or path not in TERMINAL_PATHS: |
| self.store.record_rejected_post( |
| session_digest, |
| path, |
| self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower(), |
| raw_body, |
| ) |
| self._send(404, b"Not Found", content_type="text/plain; charset=utf-8", cookies=cookies) |
| return |
| media_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower() |
| try: |
| fields = parse_qsl(raw_body.decode("utf-8"), keep_blank_values=True, strict_parsing=True) |
| except (UnicodeDecodeError, ValueError): |
| fields = [] |
|
|
| status, outcome = self.store.terminal_request( |
| session_digest, |
| path, |
| media_type, |
| raw_body, |
| fields, |
| self._flow_digest(), |
| self._terminal_source_is_canonical(), |
| ) |
| if status == 303: |
| cookies.append(browser_cookie(FLOW_COOKIE, "", max_age=0)) |
| target_lines = [ |
| line |
| for line in self.store.cart(session_digest) |
| if str(line.get("asin") or "") == TARGET_ASIN |
| ] |
| location = "/gp/cart/view.html" |
| if len(target_lines) == 1: |
| location = ADD_TO_CART_CONFIRMATION_PATH + "?" + urlencode( |
| {"lineID": str(target_lines[0]["line_id"])} |
| ) |
| self._send( |
| 303, |
| b"", |
| headers={"Location": location}, |
| cookies=cookies, |
| ) |
| return |
|
|
| message = { |
| "wrong-form-body": "Choose quantity 2 and submit the Amazon add-to-cart form once.", |
| "missing-navigation-sequence": "Open the External SSD Best Sellers list before this item.", |
| "wrong-navigation-stage": "Follow the Best Sellers → Samsung T7 journey in the same browser session.", |
| "invalid-flow-capability": "The product-page journey expired. Open the item from Best Sellers again.", |
| "invalid-terminal-source": "Submit the Add to cart form from the current Samsung T7 product page.", |
| "stale-navigation-sequence": "Return to the Samsung T7 product page before adding it to the cart.", |
| "capability-already-consumed": "This add-to-cart action was already completed.", |
| "target-line-already-exists": "The target item is already in this cart.", |
| }.get(outcome, f"The add-to-cart request did not match the local contract ({outcome}).") |
| self._send_html( |
| 409, |
| views.error_page(message, self.store.cart_count(session_digest), 409), |
| cookies=cookies, |
| ) |
|
|
|
|
| class AdminHandler(BaseHTTPRequestHandler): |
| protocol_version = "HTTP/1.1" |
| store: Store |
| admin_token: str |
| smtp_summary: dict[str, object] = {"mode": "LOCAL_ONLY"} |
| server_version = "AmazonCloneAdmin/0.1" |
|
|
| def log_message(self, format_string: str, *args: Any) -> None: |
| sys.stdout.write( |
| json.dumps( |
| { |
| "stream": "admin", |
| "client": self.client_address[0], |
| "method": self.command, |
| "path": self.path, |
| "message": format_string % args, |
| }, |
| ensure_ascii=False, |
| ) |
| + "\n" |
| ) |
| sys.stdout.flush() |
|
|
| def _authorized(self) -> bool: |
| candidate = self.headers.get("X-Bench-Admin-Token", "") |
| return bool(candidate) and secrets.compare_digest(candidate, self.admin_token) |
|
|
| def _send_json(self, status: int, payload: Any) -> None: |
| body = json_bytes(payload) |
| self.send_response(status) |
| self.send_header("Content-Type", "application/json; charset=utf-8") |
| self.send_header("Content-Length", str(len(body))) |
| self.send_header("Cache-Control", "no-store") |
| self.send_header("X-Content-Type-Options", "nosniff") |
| self.end_headers() |
| if self.command != "HEAD": |
| self.wfile.write(body) |
|
|
| def _not_found(self) -> None: |
| self._send_json(404, {"error": "not-found"}) |
|
|
| def _payload(self) -> dict[str, Any]: |
| content_length = int(self.headers.get("Content-Length", "0") or "0") |
| if content_length < 0 or content_length > MAX_ADMIN_BYTES: |
| raise ContractError("admin payload is too large") |
| if content_length == 0: |
| return {} |
| raw = self.rfile.read(content_length) |
|
|
| def unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]: |
| result: dict[str, Any] = {} |
| for key, value in pairs: |
| if key in result: |
| raise ContractError(f"duplicate admin field: {key}") |
| result[key] = value |
| return result |
|
|
| def reject_constant(value: str) -> None: |
| raise ContractError(f"invalid JSON constant: {value}") |
|
|
| payload = json.loads( |
| raw.decode("utf-8"), |
| object_pairs_hook=unique_object, |
| parse_constant=reject_constant, |
| ) |
| if not isinstance(payload, dict): |
| raise ContractError("admin payload must be an object") |
| return payload |
|
|
| def do_HEAD(self) -> None: |
| self.do_GET() |
|
|
| def do_GET(self) -> None: |
| if not self._authorized(): |
| self._not_found() |
| return |
| path = urlsplit(self.path).path |
| if path == "/__bench/health": |
| self._send_json( |
| 200, |
| { |
| "ok": True, |
| "schema": "amazon-clone.admin.v1", |
| "snapshot_id": self.store.meta().get("snapshot_id"), |
| "mail_transport": self.smtp_summary, |
| "mail_delivery_status": self.store.mail_delivery_health(), |
| }, |
| ) |
| elif path == "/__bench/state": |
| self._send_json(200, self.store.normalized_state()) |
| elif path == "/__bench/journal": |
| self._send_json(200, {"schema": "amazon-clone.journal.v1", "requests": self.store.journal()}) |
| elif path == "/__bench/auth/registration-outbox": |
| self._send_json( |
| 200, |
| { |
| "schema": "amazon-clone.registration-outbox.v1", |
| "delivery": self.smtp_summary["mode"], |
| "messages": self.store.registration_outbox(), |
| }, |
| ) |
| elif path == "/__bench/auth/password-reset-outbox": |
| self._send_json( |
| 200, |
| { |
| "schema": "amazon-clone.password-reset-outbox.v1", |
| "delivery": self.smtp_summary["mode"], |
| "messages": self.store.password_reset_outbox(), |
| }, |
| ) |
| elif path == "/__bench/mail/outbox": |
| self._send_json( |
| 200, |
| { |
| "schema": "amazon-clone.mail-outbox.v1", |
| "delivery": self.smtp_summary["mode"], |
| "messages": self.store.mail_delivery_outbox(), |
| }, |
| ) |
| else: |
| self._not_found() |
|
|
| def do_POST(self) -> None: |
| if not self._authorized(): |
| self._not_found() |
| return |
| path = urlsplit(self.path).path |
| try: |
| payload = self._payload() |
| if path == "/__bench/reset": |
| unknown = set(payload) - {"fixture"} |
| if unknown: |
| raise ContractError(f"unsupported reset fields: {sorted(unknown)}") |
| state = self.store.reset(payload.get("fixture", "task-frozen-900136-v1.json")) |
| self._send_json(200, state) |
| elif path == "/__bench/clock/advance": |
| unknown = set(payload) - {"seconds"} |
| if unknown: |
| raise ContractError(f"unsupported clock fields: {sorted(unknown)}") |
| now = self.store.advance_clock(int(payload.get("seconds", 0))) |
| self._send_json(200, {"controlled_now": now}) |
| elif path == "/__bench/orders/advance": |
| if set(payload) != {"orderID", "targetStatus"}: |
| raise ContractError( |
| "order advancement requires exactly orderID and targetStatus" |
| ) |
| order_id = payload["orderID"] |
| if ( |
| isinstance(order_id, bool) |
| or not isinstance(order_id, (int, str)) |
| or re.fullmatch(r"[1-9][0-9]{0,18}", str(order_id)) is None |
| or not isinstance(payload["targetStatus"], str) |
| ): |
| raise ContractError("invalid order advancement payload") |
| order = self.store.advance_order_shipment( |
| order_id, payload["targetStatus"] |
| ) |
| self._send_json( |
| 200, |
| { |
| "schema": "amazon-clone.order-lifecycle.v1", |
| "order": order, |
| }, |
| ) |
| elif path == "/__bench/returns/advance": |
| if set(payload) != {"returnID", "targetStatus"}: |
| raise ContractError( |
| "return advancement requires exactly returnID and targetStatus" |
| ) |
| return_id = payload["returnID"] |
| if ( |
| isinstance(return_id, bool) |
| or not isinstance(return_id, (int, str)) |
| or re.fullmatch(r"[1-9][0-9]{0,18}", str(return_id)) is None |
| or not isinstance(payload["targetStatus"], str) |
| ): |
| raise ContractError("invalid return advancement payload") |
| order = self.store.advance_return_request( |
| return_id, payload["targetStatus"] |
| ) |
| self._send_json( |
| 200, |
| { |
| "schema": "amazon-clone.return-lifecycle.v1", |
| "order": order, |
| }, |
| ) |
| else: |
| self._not_found() |
| except (OrderNotFound, ReturnNotFound): |
| self._not_found() |
| except OrderStateConflict as exc: |
| self._send_json( |
| 409, {"error": "state-conflict", "detail": str(exc)} |
| ) |
| except (ContractError, ValueError, json.JSONDecodeError) as exc: |
| self._send_json(400, {"error": "invalid-request", "detail": str(exc)}) |
|
|
|
|
| def resolve_admin_token(admin_host: str, configured_token: str | None) -> str: |
| normalized_host = admin_host.strip().strip("[]") |
| try: |
| is_loopback = ipaddress.ip_address(normalized_host).is_loopback |
| except ValueError: |
| is_loopback = normalized_host.casefold() == "localhost" |
| token = (configured_token or "").strip() |
| if is_loopback: |
| return token or "local-amazon-bench" |
| if ( |
| len(token) < 32 |
| or token == "local-amazon-bench" |
| or any(ord(character) < 33 or ord(character) > 126 for character in token) |
| ): |
| raise ValueError( |
| "a non-loopback admin host requires an explicit strong " |
| "AMAZON_ADMIN_TOKEN or --admin-token (at least 32 visible characters)" |
| ) |
| return token |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description="Run the clean local Amazon benchmark clone") |
| parser.add_argument("--host", default=os.environ.get("AMAZON_HOST", "127.0.0.1")) |
| parser.add_argument("--port", type=int, default=int(os.environ.get("PORT", "8153"))) |
| parser.add_argument("--admin-host", default=os.environ.get("AMAZON_ADMIN_HOST", "127.0.0.1")) |
| parser.add_argument("--admin-port", type=int, default=int(os.environ.get("AMAZON_ADMIN_PORT", "8154"))) |
| parser.add_argument("--admin-token", default=os.environ.get("AMAZON_ADMIN_TOKEN")) |
| parser.add_argument( |
| "--db", |
| type=Path, |
| default=Path(os.environ.get("AMAZON_DB_PATH", str(DEFAULT_DB))), |
| ) |
| parser.add_argument("--fixture", default="task-frozen-900136-v1.json") |
| parser.add_argument( |
| "--authorize-legacy-site-binding", |
| action="store_true", |
| help=( |
| "one-time explicit adoption of a recognizable unbound Amazon " |
| "database; never enabled by the deployment descriptor" |
| ), |
| ) |
| args = parser.parse_args() |
| try: |
| args.admin_token = resolve_admin_token(args.admin_host, args.admin_token) |
| except ValueError as exc: |
| parser.error(str(exc)) |
| return args |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| try: |
| public_basic_auth_credentials() |
| except ValueError as exc: |
| print(json.dumps({"event": "amazon-clone-config-error", "error": str(exc)})) |
| return 2 |
| try: |
| external_registration_verification = ( |
| load_external_registration_verification() |
| ) |
| except VerificationConfigurationError as exc: |
| print( |
| json.dumps( |
| { |
| "event": "amazon-clone-config-error", |
| "error": str(exc), |
| } |
| ) |
| ) |
| return 2 |
| try: |
| payment_config = load_payment_config() |
| except StripeConfigurationError as exc: |
| print( |
| json.dumps( |
| { |
| "event": "amazon-clone-config-error", |
| "error": str(exc), |
| } |
| ) |
| ) |
| return 2 |
| smtp_config = load_smtp_config() |
| local_inbox_url = load_local_inbox_url(smtp_config) |
| store = Store( |
| args.db.resolve(), |
| SCHEMA_PATH, |
| FIXTURE_ROOT, |
| authorize_legacy_site_binding=args.authorize_legacy_site_binding, |
| ) |
| store.ensure_seeded(args.fixture) |
| wishlist.ensure_wishlist_schema(store) |
|
|
| PublicHandler.store = store |
| PublicHandler.smtp_config = smtp_config |
| PublicHandler.local_inbox_url = local_inbox_url |
| PublicHandler.external_registration_verification = ( |
| external_registration_verification |
| ) |
| PublicHandler.payment_config = payment_config |
| PublicHandler.stripe_gateway = ( |
| StripeGateway(str(payment_config.api_base)) |
| if payment_config.stripe_enabled |
| else None |
| ) |
| AdminHandler.store = store |
| AdminHandler.admin_token = args.admin_token |
| AdminHandler.smtp_summary = smtp_public_summary(smtp_config) |
|
|
| released_mail_claims = 0 |
| replayed_mail_jobs = 0 |
| expired_mail_jobs = 0 |
| exhausted_mail_jobs = 0 |
| localized_mail_jobs = 0 |
| if smtp_config is not None: |
| expired_mail_jobs = store.expire_stale_pending_auth_mail() |
| exhausted_mail_jobs = store.fail_exhausted_pending_mail() |
| released_mail_claims = store.recover_pending_mail_claims() |
| for delivery in store.pending_mail_deliveries(): |
| if dispatch_mail_delivery(store, smtp_config, delivery): |
| replayed_mail_jobs += 1 |
| else: |
| localized_mail_jobs = store.reconcile_mail_for_local_only() |
|
|
| public_server = ReusableThreadingHTTPServer((args.host, args.port), PublicHandler) |
| admin_server = ReusableThreadingHTTPServer((args.admin_host, args.admin_port), AdminHandler) |
| admin_thread = threading.Thread(target=admin_server.serve_forever, name="amazon-clone-admin", daemon=True) |
| admin_thread.start() |
|
|
| stopping = threading.Event() |
|
|
| def stop_servers(*_: Any) -> None: |
| if stopping.is_set(): |
| return |
| stopping.set() |
| threading.Thread(target=public_server.shutdown, daemon=True).start() |
| threading.Thread(target=admin_server.shutdown, daemon=True).start() |
|
|
| if threading.current_thread() is threading.main_thread(): |
| signal.signal(signal.SIGINT, stop_servers) |
| if hasattr(signal, "SIGTERM"): |
| signal.signal(signal.SIGTERM, stop_servers) |
|
|
| print( |
| json.dumps( |
| { |
| "event": "amazon-clone-started", |
| "public": f"http://{args.host}:{args.port}", |
| "admin": f"http://{args.admin_host}:{args.admin_port}", |
| "db": str(args.db.resolve()), |
| "snapshot": store.meta().get("snapshot_id"), |
| "mail_transport": smtp_public_summary(smtp_config), |
| "registration_verification": ( |
| "redis-resend" |
| if external_registration_verification is not None |
| else "offline-local" |
| ), |
| "payment_mode": payment_config.mode, |
| "mail_startup_replay": { |
| "expired_auth_jobs": expired_mail_jobs, |
| "exhausted_jobs": exhausted_mail_jobs, |
| "released_claims": released_mail_claims, |
| "dispatched": replayed_mail_jobs, |
| "localized_jobs": localized_mail_jobs, |
| }, |
| }, |
| ensure_ascii=False, |
| ), |
| flush=True, |
| ) |
| try: |
| public_server.serve_forever() |
| finally: |
| public_server.server_close() |
| admin_server.shutdown() |
| admin_server.server_close() |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
