", pane)
source = source[:pane] + content + source[controls:]
if not show_next:
source = re.sub(
r"
]*value=Next[^>]*>", "", source, count=1, flags=re.I
)
labels = ("Where", "When", "Vehicle", "Deals", "Your details")
for index, label in enumerate(labels):
pattern = (
rf'
]*>{re.escape(label)}'
)
replacement = (
f'
'
f"{label}"
)
source = re.sub(pattern, replacement, source, count=1)
return HTMLResponse(source)
app = FastAPI(title="AutoSlash offline clone", docs_url=None, redoc_url=None)
app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
@app.middleware("http")
async def security_boundary(request: Request, call_next: Any) -> Response:
if request.method not in {"GET", "HEAD", "OPTIONS"}:
origin = request.headers.get("origin")
parsed = urlparse(origin or "")
if (
not origin
or parsed.scheme != request.url.scheme
or parsed.netloc != request.url.netloc
or parsed.path not in {"", "/"}
or parsed.params
or parsed.query
or parsed.fragment
):
return JSONResponse(
{"detail": "same-origin mutation proof required"}, status_code=403
)
response = await call_next(request)
response.headers.setdefault("content-security-policy", CONTENT_SECURITY_POLICY)
response.headers.setdefault("x-content-type-options", "nosniff")
response.headers.setdefault("referrer-policy", "same-origin")
return response
@app.get("/__websitebench/health")
async def websitebench_health() -> dict[str, str]:
with _backend().lifecycle.connection() as connection:
connection.execute("SELECT 1").fetchone()
return {"status": "ok"}
@app.get("/healthz")
async def healthz() -> dict[str, Any]:
with _backend().lifecycle.connection() as connection:
connection.execute("SELECT 1").fetchone()
return {"ok": True, "site_id": SITE_ID}
@app.get("/", include_in_schema=False)
@app.get("/quote", include_in_schema=False)
@app.get("/get-a-quote", include_in_schema=False)
async def home(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("quote-home"), token)
@app.get("/quote/pickup-location", include_in_schema=False)
async def pickup_location_entry(request: Request) -> Response:
return await home(request)
@app.post("/quote/pickup-location", include_in_schema=False)
async def pickup_location(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
location_type = _form_value(values, "location_type", "airport")
local_pickup = _form_value(values, "location")
airport_pickup = _form_value(values, "airport") or _form_value(
values, "AirportId-display"
)
if location_type == "non-airport" and local_pickup:
pickup = local_pickup
else:
location_type = "airport"
pickup = airport_pickup
if not pickup:
return _finish(request, _reference_page("quote-home"), token)
with _backend().lifecycle.connection(transaction=True) as connection:
connection.execute(
"DELETE FROM autoslash_quote_drafts WHERE owner_id=?", (owner,)
)
save_draft(
connection, "autoslash_quote_drafts", owner, "where",
{"pickup": pickup, "location_type": location_type},
)
content = (
f'
Do you want to return your rental to the same location?
'
f'
({_safe(pickup)})
'
''
'
'
)
return _finish(
request,
_captured_quote_step("/quote/dropoff-location", content, 1, show_next=False),
token,
)
@app.post("/quote/dropoff-location", include_in_schema=False)
async def quote_dropoff_location(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
same = _form_value(values, "same_location", "yes")
dropoff = _form_value(values, "dropoff")
with _backend().lifecycle.connection(transaction=True) as connection:
draft = read_draft(connection, "autoslash_quote_drafts", owner)
pickup = str(draft.get("pickup", ""))
if same == "no" and not dropoff:
content = (
"
Where will you return the rental?
"
'
'
'
'
)
response = _captured_quote_step("/quote/dropoff-location", content, 1)
return _finish(request, response, token)
destination = pickup if same == "yes" else dropoff
if not _advance_draft(
connection, "autoslash_quote_drafts", owner, "where", "pickup-date",
{"dropoff": destination, "same_location": same},
):
return _finish(
request,
_workflow_conflict(
"Start your quote again",
"The previous location step is missing or no longer current.",
"/", "quote-workflow-required",
),
token,
)
content = (
"
When will you pick up the rental?
"
'
'
'
'
"
Non-airport locations are typically open 8am-5pm Mon-Fri, "
"8am-12pm Sat, closed Sun.
"
)
return _finish(
request, _captured_quote_step("/quote/pickup-date", content, 2), token
)
@app.get("/quote/pickup-date", include_in_schema=False)
async def quote_pickup_date_get(request: Request) -> Response:
_, token = _owner(request)
content = (
"
When will you pick up the rental?
"
'
'
'
'
)
return _finish(
request, _captured_quote_step("/quote/pickup-date", content, 2), token
)
@app.post("/quote/pickup-date", include_in_schema=False)
async def quote_pickup_date(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
pickup_date = _form_value(values, "pickup_date")
pickup_time = _form_value(values, "pickup_time", "12:00")
if not _valid_date(pickup_date) or not _valid_time(pickup_time):
return await quote_pickup_date_get(request)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_quote_drafts", owner, "pickup-date", "dropoff-date",
{"pickup_date": pickup_date, "pickup_time": pickup_time},
):
return _finish(
request,
_workflow_conflict(
"Start your quote again",
"Complete the location steps before choosing dates.",
"/", "quote-workflow-required",
),
token,
)
content = (
"
When will you drop off the rental?
"
'
'
'
'
)
return _finish(
request, _captured_quote_step("/quote/dropoff-date", content, 2), token
)
@app.post("/quote/dropoff-date", include_in_schema=False)
async def quote_dropoff_date(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
dropoff_date = _form_value(values, "dropoff_date")
dropoff_time = _form_value(values, "dropoff_time", "12:00")
with _backend().lifecycle.connection() as connection:
draft = read_draft(connection, "autoslash_quote_drafts", owner)
pickup_date = str(draft.get("pickup_date", ""))
if (
not _valid_date(dropoff_date)
or not _valid_time(dropoff_time)
or not _valid_date(pickup_date)
or dropoff_date < pickup_date
):
response = _captured_quote_step(
"/quote/dropoff-date",
"
When will you drop off the rental?
"
'
Select a drop-off date after the pickup date.
'
'
',
2,
)
return _finish(request, response, token)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_quote_drafts", owner, "dropoff-date", "vehicle",
{"dropoff_date": dropoff_date, "dropoff_time": dropoff_time},
):
return _finish(
request,
_workflow_conflict(
"Start your quote again",
"Complete the pickup-date step before choosing a drop-off date.",
"/", "quote-workflow-required",
),
token,
)
return _finish(request, _reference_page("quote-vehicle"), token)
@app.get("/quote/vehicle", include_in_schema=False)
async def quote_vehicle(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("quote-vehicle"), token)
@app.post("/quote/vehicle", include_in_schema=False)
async def quote_vehicle_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
vehicle = _form_value(values, "CarClass")
if vehicle not in VEHICLE_LABELS:
return _finish(request, _reference_page("quote-vehicle"), token)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_quote_drafts", owner, "vehicle", "deals",
{"vehicle_class": vehicle},
):
return _finish(
request,
_workflow_conflict(
"Start your quote again",
"Complete the location and date steps before choosing a vehicle.",
"/", "quote-workflow-required",
),
token,
)
return _finish(request, _reference_page("quote-memberships"), token)
@app.get("/quote/memberships", include_in_schema=False)
async def quote_memberships(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("quote-memberships"), token)
@app.post("/quote/memberships", include_in_schema=False)
async def quote_memberships_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
deals = values.get("AffiliationIds", [])
if not deals or any(deal not in AFFILIATION_LABELS for deal in deals):
return _finish(request, _reference_page("quote-memberships"), token)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_quote_drafts", owner, "deals", "contact",
{"affiliation_ids": deals},
):
return _finish(
request,
_workflow_conflict(
"Start your quote again",
"Choose a vehicle before adding memberships and discounts.",
"/", "quote-workflow-required",
),
token,
)
return _finish(request, _reference_page("quote-contact"), token)
@app.get("/quote/contact-info", include_in_schema=False)
async def quote_contact_info(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("quote-contact"), token)
@app.post("/quote/contact-info", include_in_schema=False)
async def quote_contact_info_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
first = _form_value(values, "FirstName")
last = _form_value(values, "LastName")
email = _form_value(values, "Email").casefold()
confirm = _form_value(values, "ConfirmEmail").casefold()
license_country = _form_value(values, "PointOfSaleCountry")
if not first or not last or not EMAIL_RE.fullmatch(email) or email != confirm:
return _finish(request, _reference_page("quote-contact"), token)
request_id = _request_id("ASQ")
backend = _backend()
with backend.lifecycle.connection(transaction=True) as connection:
draft = connection.execute(
"SELECT stage,payload_json FROM autoslash_quote_drafts WHERE owner_id=?",
(owner,),
).fetchone()
required = {
"pickup", "location_type", "dropoff", "same_location",
"pickup_date", "pickup_time", "dropoff_date", "dropoff_time",
"vehicle_class", "affiliation_ids",
}
payload = json.loads(draft["payload_json"]) if draft is not None else {}
if draft is None or draft["stage"] != "contact" or not required <= payload.keys():
response = _information_page(
"Complete your quote first",
(
"Complete the earlier quote steps before submitting contact information.",
"Return to Get a Quote to choose locations, dates, vehicle, and deals.",
),
"quote-workflow-required",
)
response.status_code = 409
return _finish(request, response, token)
if license_country not in COUNTRY_LABELS:
return _finish(request, _reference_page("quote-contact"), token)
payload.update({
"first_name": first,
"last_name": last,
"email": email,
"license_country": license_country,
})
connection.execute(
"INSERT INTO autoslash_quote_requests"
"(request_id,owner_id,payload_json,status,created_at) VALUES (?,?,?,?,?)",
(request_id, owner, json.dumps(payload, sort_keys=True), "received", utc_now()),
)
backend.mail.enqueue(
"quote-request", email, {"request_id": request_id},
idempotency_key=f"quote:{request_id}", simulation=True, connection=connection,
)
connection.execute(
"DELETE FROM autoslash_quote_drafts WHERE owner_id=?", (owner,)
)
response = RedirectResponse("/quote/confirmation", status_code=303)
return _finish(request, response, token)
@app.get("/quote/confirmation", include_in_schema=False)
async def quote_confirmation(request: Request) -> Response:
owner, token = _owner(request)
with _backend().lifecycle.connection() as connection:
row = connection.execute(
"SELECT request_id,payload_json FROM autoslash_quote_requests "
"WHERE owner_id=? ORDER BY created_at DESC,rowid DESC LIMIT 1",
(owner,),
).fetchone()
if row is None:
return _finish(request, RedirectResponse("/", status_code=303), token)
payload = json.loads(row["payload_json"])
response = _confirmation(
"Thanks! We're working on your quote.",
"Your quote request has been received. No credit card is required.",
str(row["request_id"]),
"quote-confirmation",
(
("Pickup", payload["pickup"]),
("Drop-off", payload["dropoff"]),
(
"Pickup date",
_display_date(payload["pickup_date"], include_time=payload["pickup_time"]),
),
(
"Drop-off date",
_display_date(payload["dropoff_date"], include_time=payload["dropoff_time"]),
),
("Vehicle", VEHICLE_LABELS.get(payload["vehicle_class"], payload["vehicle_class"])),
(
"Cards and discounts",
", ".join(
AFFILIATION_LABELS.get(item, item)
for item in payload["affiliation_ids"]
),
),
("Primary driver", f'{payload["first_name"]} {payload["last_name"]}'),
(
"Driver's license issued by",
COUNTRY_LABELS.get(payload["license_country"], payload["license_country"]),
),
),
)
return _finish(request, response, token)
@app.get("/track", include_in_schema=False)
@app.get("/track-a-rental", include_in_schema=False)
async def track(request: Request) -> Response:
_, token = _owner(request)
fields = (
_select("Company", "CompanyId", COMPANIES, "select your rental company")
+ _field(
"Confirmation Number", "TrackingConfirmationNumber",
placeholder="rental confirmation number",
)
)
return _finish(
request,
_tracking_page(
1, "Enter your rental company and confirmation number:",
"/price-tracking/confirmation", fields,
),
token,
)
@app.post("/price-tracking/confirmation", include_in_schema=False)
async def tracking_confirmation(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
company = _form_value(values, "CompanyId")
confirmation = _form_value(
values, "TrackingConfirmationNumber"
) or _form_value(values, "ConfirmationNumber")
if company not in COMPANIES or not confirmation:
response = _tracking_page(
1, "Enter your rental company and confirmation number:",
"/price-tracking/confirmation",
_select("Company", "CompanyId", COMPANIES, "select your rental company")
+ _field(
"Confirmation Number", "TrackingConfirmationNumber",
placeholder="rental confirmation number",
),
message="Choose a rental company and enter your confirmation number.",
)
return _finish(request, response, token)
with _backend().lifecycle.connection(transaction=True) as connection:
connection.execute(
"DELETE FROM autoslash_tracking_drafts WHERE owner_id=?", (owner,)
)
save_draft(
connection, "autoslash_tracking_drafts", owner, "date",
{"company": company, "confirmation": confirmation},
)
fields = _field("Pickup date", "pickup_date", input_type="date") + _field(
"Drop-off date", "dropoff_date", input_type="date"
)
return _finish(
request,
_tracking_page(2, "When is your rental?", "/price-tracking/date", fields),
token,
)
@app.post("/price-tracking/date", include_in_schema=False)
async def tracking_date(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
pickup_date = _form_value(values, "pickup_date")
dropoff_date = _form_value(values, "dropoff_date")
if (
not _valid_date(pickup_date)
or not _valid_date(dropoff_date)
or dropoff_date < pickup_date
):
response = _tracking_page(
2, "When is your rental?", "/price-tracking/date",
_field("Pickup date", "pickup_date", input_type="date")
+ _field("Drop-off date", "dropoff_date", input_type="date"),
message="Enter a valid pickup and drop-off date.",
)
return _finish(request, response, token)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_tracking_drafts", owner, "date", "price",
{"pickup_date": pickup_date, "dropoff_date": dropoff_date},
):
return _finish(
request,
_workflow_conflict(
"Start price tracking again",
"Enter the rental company and confirmation number before the dates.",
"/track", "tracking-workflow-required",
),
token,
)
fields = _field(
"Total rental price", "total_price", input_type="number", placeholder="0.00"
) + _field(
"Currency", "currency", value="USD", required=True
)
return _finish(
request,
_tracking_page(
3, "What price did you book?", "/price-tracking/price", fields
),
token,
)
@app.post("/price-tracking/price", include_in_schema=False)
async def tracking_price(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
total = _form_value(values, "total_price")
try:
valid_total = 0 < float(total) < 100000
except ValueError:
valid_total = False
if not valid_total:
response = _tracking_page(
3, "What price did you book?", "/price-tracking/price",
_field("Total rental price", "total_price", input_type="number"),
message="Enter the total price shown on your reservation.",
)
return _finish(request, response, token)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_tracking_drafts", owner, "price", "deals",
{"total_price": total, "currency": "USD"},
):
return _finish(
request,
_workflow_conflict(
"Start price tracking again",
"Enter the reservation dates before its total price.",
"/track", "tracking-workflow-required",
),
token,
)
fields = (
'
"
)
return _finish(
request,
_tracking_page(
4, "Tell us about your eligible discounts:",
"/price-tracking/deals", fields,
),
token,
)
@app.post("/price-tracking/deals", include_in_schema=False)
async def tracking_deals(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
with _backend().lifecycle.connection(transaction=True) as connection:
if not _advance_draft(
connection, "autoslash_tracking_drafts", owner, "deals", "email",
{"deals": values.get("deals", [])},
):
return _finish(
request,
_workflow_conflict(
"Start price tracking again",
"Enter the booked price before selecting eligible discounts.",
"/track", "tracking-workflow-required",
),
token,
)
fields = _field(
"Email", "email", input_type="email", placeholder="ex. janedoe@example.com"
) + _field(
"Confirm Email", "confirm_email", input_type="email", placeholder="confirm email"
)
return _finish(
request,
_tracking_page(
5, "Where should we send price-drop alerts?",
"/price-tracking/email", fields,
),
token,
)
@app.post("/price-tracking/email", include_in_schema=False)
async def tracking_email(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
email = _form_value(values, "email").casefold()
confirm = _form_value(values, "confirm_email").casefold()
if not EMAIL_RE.fullmatch(email) or email != confirm:
response = _tracking_page(
5, "Where should we send price-drop alerts?",
"/price-tracking/email",
_field("Email", "email", input_type="email")
+ _field("Confirm Email", "confirm_email", input_type="email"),
message="Enter the same valid email address twice.",
)
return _finish(request, response, token)
request_id = _request_id("AST")
backend = _backend()
with backend.lifecycle.connection(transaction=True) as connection:
draft = connection.execute(
"SELECT stage,payload_json FROM autoslash_tracking_drafts WHERE owner_id=?",
(owner,),
).fetchone()
required = {
"company", "confirmation", "pickup_date", "dropoff_date",
"total_price", "currency", "deals",
}
payload = json.loads(draft["payload_json"]) if draft is not None else {}
if draft is None or draft["stage"] != "email" or not required <= payload.keys():
response = _information_page(
"Complete price tracking first",
(
"Complete the earlier tracking steps before submitting an email.",
"Return to Track a Rental to add the reservation, dates, price, and deals.",
),
"tracking-workflow-required",
)
response.status_code = 409
return _finish(request, response, token)
payload["email"] = email
connection.execute(
"INSERT INTO autoslash_tracking_requests"
"(request_id,owner_id,payload_json,status,created_at) VALUES (?,?,?,?,?)",
(request_id, owner, json.dumps(payload, sort_keys=True), "watching", utc_now()),
)
backend.mail.enqueue(
"price-tracking", email, {"request_id": request_id},
idempotency_key=f"tracking:{request_id}", simulation=True,
connection=connection,
)
connection.execute(
"DELETE FROM autoslash_tracking_drafts WHERE owner_id=?", (owner,)
)
response = RedirectResponse("/price-tracking/complete", status_code=303)
return _finish(request, response, token)
@app.get("/price-tracking/complete", include_in_schema=False)
async def tracking_complete(request: Request) -> Response:
owner, token = _owner(request)
with _backend().lifecycle.connection() as connection:
row = connection.execute(
"SELECT request_id,payload_json FROM autoslash_tracking_requests "
"WHERE owner_id=? ORDER BY created_at DESC,rowid DESC LIMIT 1",
(owner,),
).fetchone()
if row is None:
return _finish(request, RedirectResponse("/track", status_code=303), token)
payload = json.loads(row["payload_json"])
response = _confirmation(
"We'll watch for lower prices.",
"If a lower rate appears, AutoSlash notifies you. You decide whether to "
"rebook and cancel the old reservation; no automatic rebooking occurs.",
str(row["request_id"]),
"tracking-confirmation",
(
("Rental company", payload["company"]),
("Confirmation number", payload["confirmation"]),
("Pickup date", _display_date(payload["pickup_date"])),
("Drop-off date", _display_date(payload["dropoff_date"])),
("Booked total", f'${float(payload["total_price"]):.2f} {payload["currency"]}'),
("Eligible discounts", ", ".join(payload["deals"]) or "None selected"),
),
)
return _finish(request, response, token)
@app.get("/reservations/lookup", include_in_schema=False)
async def reservation_lookup(request: Request) -> Response:
_, token = _owner(request)
response = _plain_form_page(
"Reservation Lookup",
'View or cancel an existing reservation. '
'
Don\'t remember your Trip ID?',
"/reservations/lookup",
_field(
"Trip ID or Confirmation Number", "confirmation",
placeholder="from your confirmation email",
)
+ _field("Email", "email", input_type="email", placeholder="ex. janedoe@example.com"),
view="reservation-lookup",
extra='
Booked with Priceline?
',
)
return _finish(request, response, token)
@app.post("/reservations/lookup", include_in_schema=False)
async def reservation_lookup_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
confirmation = _form_value(values, "confirmation")
email = _form_value(values, "email").casefold()
if not confirmation or not EMAIL_RE.fullmatch(email):
return await reservation_lookup(request)
request_id = _request_id("ASL")
with _backend().lifecycle.connection(transaction=True) as connection:
connection.execute(
"INSERT INTO autoslash_lookup_requests"
"(request_id,owner_id,confirmation_digest,email_digest,status,created_at) "
"VALUES (?,?,?,?,?,?)",
(
request_id, owner, _digest(confirmation, "confirmation"),
_digest(email, "email"), "not-found-local", utc_now(),
),
)
response = _confirmation(
"We couldn't find a local reservation.",
"This offline review database contains no source-site reservations. "
"Check the Trip ID and email or request a Trip ID reminder.",
request_id,
"reservation-lookup",
)
return _finish(request, response, token)
@app.get("/reservations/forgot", include_in_schema=False)
@app.get("/reservations/email", include_in_schema=False)
async def forgot_trip(request: Request) -> Response:
_, token = _owner(request)
response = _plain_form_page(
"Forgot your Trip ID?",
"Enter the email address used for your AutoSlash quote or tracked rental.",
"/reservations/forgot",
_field("Email", "email", input_type="email", placeholder="ex. janedoe@example.com"),
view="forgot-trip",
)
return _finish(request, response, token)
@app.post("/reservations/forgot", include_in_schema=False)
@app.post("/reservations/email", include_in_schema=False)
async def forgot_trip_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
email = _form_value(values, "email").casefold()
if not EMAIL_RE.fullmatch(email):
return await forgot_trip(request)
request_id = _request_id("ASR")
backend = _backend()
with backend.lifecycle.connection(transaction=True) as connection:
backend.mail.enqueue(
"trip-id-recovery", email, {"request_id": request_id},
idempotency_key=f"recovery:{owner}:{request_id}",
simulation=True, connection=connection,
)
response = _confirmation(
"Check your email.",
"If this address matches a local record, recovery instructions were placed "
"in the local-only outbox. The public response does not reveal a match.",
request_id,
"forgot-trip",
)
return _finish(request, response, token)
@app.get("/contact-us", include_in_schema=False)
async def contact_us(request: Request) -> Response:
_, token = _owner(request)
fields = (
_field("Name", "name", placeholder="ex. Jane Doe")
+ _field("Email", "email", input_type="email", placeholder="ex. janedoe@example.com")
+ _field("Confirm Email", "confirm_email", input_type="email", placeholder="confirm email")
+ _field("Subject", "subject", placeholder="ex. tracking help")
+ '
'
)
response = _plain_form_page(
"Contact AutoSlash Support",
"Fill out the form below or email us directly at support@autoslash.com.",
"/contact-us",
fields,
view="contact",
)
return _finish(request, response, token)
@app.post("/contact-us", include_in_schema=False)
async def contact_us_post(request: Request) -> Response:
owner, token = _owner(request)
values = await _form_values(request)
name = _form_value(values, "name")
email = _form_value(values, "email").casefold()
confirm = _form_value(values, "confirm_email").casefold()
subject = _form_value(values, "subject")
description = _form_value(values, "description")
if (
not name or not EMAIL_RE.fullmatch(email) or email != confirm
or not subject or not description
):
return await contact_us(request)
request_id = _request_id("ASC")
backend = _backend()
with backend.lifecycle.connection(transaction=True) as connection:
connection.execute(
"INSERT INTO autoslash_support_requests"
"(request_id,owner_id,name,email,subject,description,status,created_at) "
"VALUES (?,?,?,?,?,?,?,?)",
(request_id, owner, name, email, subject, description, "received", utc_now()),
)
backend.mail.enqueue(
"contact-request", email, {"request_id": request_id},
idempotency_key=f"contact:{request_id}",
simulation=True, connection=connection,
)
response = _confirmation(
"Thanks for contacting us.",
"Your support request was saved in the local review environment.",
request_id,
"contact",
)
return _finish(request, response, token)
@app.get("/frequently-asked-questions", include_in_schema=False)
async def help_page(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("help"), token)
@app.get("/coupons", include_in_schema=False)
async def coupons(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("coupons"), token)
@app.get("/our-story", include_in_schema=False)
async def our_story(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("story"), token)
@app.get("/how-we-do-it", include_in_schema=False)
async def how_we_do_it(request: Request) -> Response:
_, token = _owner(request)
return _finish(request, _reference_page("how"), token)
def _information_page(title: str, paragraphs: tuple[str, ...], view: str) -> HTMLResponse:
content = "".join(f"
{_safe(paragraph)}
" for paragraph in paragraphs)
return _document(
title,
view,
f'
'
f"{_safe(title)}
{content}",
)
@app.get("/in-the-news", include_in_schema=False)
async def in_the_news(request: Request) -> Response:
_, token = _owner(request)
return _finish(
request,
_information_page(
"In the News",
("AutoSlash press links open outside the first-party site.",
"External destinations are intentionally not contacted by this offline clone."),
"news",
),
token,
)
@app.get("/privacy-policy", include_in_schema=False)
async def privacy_policy(request: Request) -> Response:
_, token = _owner(request)
return _finish(
request,
_information_page(
"AUTOSLASH PRIVACY POLICY",
(
"The offline clone stores submitted synthetic review data only in its "
"site-bound local database.",
"No source-site, email, analytics, advertising, or payment request is sent.",
),
"privacy",
),
token,
)
@app.get("/terms-of-use", include_in_schema=False)
async def terms_of_use(request: Request) -> Response:
_, token = _owner(request)
return _finish(
request,
_information_page(
"Site Terms and Conditions of Use",
(
"This offline implementation reproduces the public review surface.",
"It does not book, cancel, rebook, charge, or contact a real service.",
),
"terms",
),
token,
)
@app.get("/coupons/{company}/{coupon_id}/{slug}", include_in_schema=False)
async def coupon_detail(
request: Request, company: str, coupon_id: str, slug: str
) -> Response:
_, token = _owner(request)
title = slug.replace("-", " ").title()
return _finish(
request,
_information_page(
title,
(
f"{company.title()} coupon code: {coupon_id.upper()}",
"Use Get a Quote to include eligible discounts. This page does not "
"contact a rental company.",
),
"coupon-detail",
),
token,
)
@app.get("/external-link", include_in_schema=False)
async def external_link(request: Request, destination: str = "external") -> Response:
_, token = _owner(request)
return _finish(
request,
_information_page(
"External link",
(
f"{destination.title()} is outside the offline AutoSlash clone.",
"Runtime network access is disabled, so this destination was not opened.",
),
"external-link",
),
token,
)
@app.get("/account/sign-in", include_in_schema=False)
async def sign_in_notice(request: Request) -> Response:
_, token = _owner(request)
return _finish(
request,
_information_page(
"Reservation Lookup",
(
"The verified anonymous source journey uses Trip ID and email lookup.",
"No local password account is invented for this offline clone.",
),
"reservation-lookup",
),
token,
)
@app.get("/api/session-summary")
async def session_summary(request: Request) -> Response:
owner, token = _owner(request)
with _backend().lifecycle.connection() as connection:
quote_count = int(
connection.execute(
"SELECT COUNT(*) FROM autoslash_quote_requests WHERE owner_id=?",
(owner,),
).fetchone()[0]
)
tracking_count = int(
connection.execute(
"SELECT COUNT(*) FROM autoslash_tracking_requests WHERE owner_id=?",
(owner,),
).fetchone()[0]
)
response = JSONResponse(
{"site_id": SITE_ID, "quote_requests": quote_count,
"tracking_requests": tracking_count}
)
return _finish(request, response, token)
@app.api_route(
"/{path:path}", methods=["GET"], include_in_schema=False
)
async def not_found(request: Request, path: str) -> Response:
del path
_, token = _owner(request)
body = """
Page Not Found
We're sorry, this page no longer exists.
Please visit our home page if you are not redirected in 5 seconds.
"""
return _finish(
request, _document("Page not found", "not-found", body, status_code=404), token
)
if __name__ == "__main__":
import uvicorn
uvicorn.run(
app,
host=os.environ.get("HOST", "127.0.0.1"),
port=int(os.environ.get("PORT", "3000")),
log_level="warning",
)
