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"}) # A 10,000-character review body is a supported domain value. URL-encoded # non-ASCII text can use up to twelve bytes per Unicode scalar (four UTF-8 # bytes, each percent-encoded), so keep the transport limit above that bound. 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", } ) # Ordinary cart mutations are account-owned. Buy Now is kept separate because # its existing pending-intent flow already redirects anonymous shoppers before # creating the authenticated checkout. 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: # Compatibility only for old standalone launchers. 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", "/")), ), } # Footer subjects this storefront deliberately does not model. Each gets its own # destination so a visitor lands on a page that names what they clicked and says # plainly that it is out of scope, instead of a link that goes nowhere. _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."), ) # Separate Amazon products and companies linked from the footer grid. _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): # Browsers routinely cancel in-flight static responses when a # tab navigates or closes. The response is already committed, # so treat that peer disconnect as a normal end of connection # instead of letting socketserver print a misleading traceback. 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) # Publish this browser's storefront delivery location so the header, # the mobile notice and the PDP buy box all render the same choice # without threading it through every view signature. 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 # Before OTP verification, known and unknown identifiers expose # exactly the same neutral surface. SMTP outcome and Retry are # intentionally unavailable until identity ownership is proven. 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: # One shared fallback budget fails safely when a trusted proxy did # not provide a parseable address. 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"])], } # The frozen products come from the directly observed External # SSD ranking/search surface, so Computers is an evidenced # department identity rather than a title-based inference. 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, ), # Display enrichment must not create new membership in a # frozen source facet. Supplemental cards without a # captured brand remain outside Brand filtering even if a # later PDP capture established their manufacturer. 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, ) # Frozen query/department membership comes from the captured # result set. Enrichment may fill shopping facts, but it must # not rewrite that source ordering or membership. 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: # The request body has deliberately not been consumed. Close this # HTTP/1.1 connection so those bytes cannot be parsed as a second # request after the 413 response. 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: # Keep account existence private. Existing accounts receive # the same accepted response without a registration email. 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 ) # Unknown, foreign, exhausted, and successfully queued # flows share one response contract. 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 ) # Missing, decoy, throttled, and queued flows use the # same public response to avoid account enumeration. 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) # This response is identical whether or not an account was # found; only a database-backed account can receive mail. 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: # The cart mutation already succeeded. A concurrent # removal must not turn that success into a retry that # can double the quantity. 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: # Preserve the frozen benchmark's explicit nonterminal rejection. 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", } # A rejected choice answers with the same redirect shape as an # accepted one, so a caller cannot use the status code to probe # which part of the submission was wrong. Nothing is persisted # unless every check passes, and re-submitting the same country is # a no-op rather than a second write. 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())