PUT is hedge bias — not a sell order.
" @@ -59,6 +63,7 @@ def render_share_html(ticker: str, result: dict[str, Any]) -> bytes: +{_esc(freeze)}
{_esc(posture)}
Educational only — not investment advice. Fortune Insight, LLC.
diff --git a/app/stripe_billing.py b/app/stripe_billing.py index 0ddeb33..bde547e 100644 --- a/app/stripe_billing.py +++ b/app/stripe_billing.py @@ -17,6 +17,14 @@ CHECKOUT_PLANS = frozenset({"pro", "portfolio_pro"}) +class StripeRequestError(RuntimeError): + def __init__(self, status: int, error: dict): + super().__init__(str(error.get("message") or "Stripe request failed")) + self.coupon_rejected = status == 400 and error.get("type") == "invalid_request_error" and ( + error.get("code") == "coupon_expired" or + (error.get("code") == "resource_missing" and str(error.get("param") or "").startswith("discounts"))) + + def stripe_secret() -> str: return ( os.environ.get("QUANTRADAR_STRIPE_SECRET_KEY", "").strip() @@ -69,6 +77,19 @@ def price_id_for_interval(interval: str | None) -> str: ) +def price_id_report() -> str: + return ( + os.environ.get("STRIPE_PRICE_ID_REPORT", "").strip() + or os.environ.get("QUANTRADAR_STRIPE_PRICE_ID_REPORT", "").strip() + ) + + +def price_id_bump() -> str: + return ( + os.environ.get("STRIPE_PRICE_ID_BUMP", "").strip() + or os.environ.get("QUANTRADAR_STRIPE_PRICE_ID_BUMP", "").strip() + ) + def price_id_for_plan(plan: str | None, interval: str | None = None) -> str: """Resolve Stripe Price ID for checkout plan + interval.""" plan_n = normalize_checkout_plan(plan) @@ -87,6 +108,9 @@ def create_checkout_session( interval: str | None = None, plan: str | None = "pro", mode: str = "subscription", + coupon_id: str | None = None, + customer_id: str | None = None, + idempotency_key: str | None = None, ) -> dict[str, Any]: """Create a Stripe Checkout Session. Returns {id, url, plan}.""" secret = stripe_secret() @@ -121,7 +145,10 @@ def create_checkout_session( "line_items[0][quantity]": "1", } if customer_email: - data["customer_email"] = customer_email + if customer_id: + data["customer"] = customer_id + else: + data["customer_email"] = customer_email data["client_reference_id"] = customer_email data["metadata[email]"] = customer_email data["metadata[interval]"] = iv @@ -132,6 +159,13 @@ def create_checkout_session( data["subscription_data[metadata][interval]"] = iv data["subscription_data[metadata][plan]"] = plan_n data["subscription_data[metadata][product]"] = product + if idempotency_key: + data["metadata[checkout_attempt]"] = idempotency_key + data["subscription_data[metadata][checkout_attempt]"] = idempotency_key + + if coupon_id and plan_n == "pro" and (idempotency_key or coupon_redeemable(coupon_id)): + data.pop("allow_promotion_codes", None) + data["discounts[0][coupon]"] = coupon_id body = urllib.parse.urlencode(data).encode() req = urllib.request.Request( @@ -141,6 +175,7 @@ def create_checkout_session( "Authorization": f"Bearer {secret}", "Content-Type": "application/x-www-form-urlencoded", "User-Agent": "QuantRadar-Stripe/0.5", + **({"Idempotency-Key": idempotency_key} if idempotency_key else {}), }, method="POST", ) @@ -148,8 +183,12 @@ def create_checkout_session( with urllib.request.urlopen(req, timeout=30) as resp: obj = json.loads(resp.read().decode()) except urllib.error.HTTPError as exc: - detail = exc.read().decode(errors="replace")[:800] - raise RuntimeError(f"stripe checkout failed: {exc.code} {detail}") from exc + detail = exc.read().decode(errors="replace") + try: + error = json.loads(detail).get("error") or {} + except (ValueError, AttributeError): + error = {} + raise StripeRequestError(exc.code, error) from exc return { "id": obj.get("id"), "url": obj.get("url"), @@ -159,6 +198,177 @@ def create_checkout_session( } +def create_report_checkout(*, customer_email: str, with_bump: bool = False, order: dict | None = None) -> dict[str, Any]: + """One-time $9 deep report (+ optional $5 CSV/priority order bump). + + Payment mode, never subscription — no negative-option surface at all. + """ + secret = stripe_secret() + if not secret: + raise RuntimeError("Stripe not configured") + report_price = price_id_report() + if not report_price: + raise RuntimeError("STRIPE_PRICE_ID_REPORT not configured") + if order is None or order["owner"] != customer_email or bool(order["bump"]) != with_bump: + raise ValueError("A saved report order is required before checkout") + if order.get("checkout_id"): + return {"id": order["checkout_id"], "url": order["checkout_url"], "order_id": order["id"], "product": "report"} + base = public_base_url() + data: dict[str, str] = { + "mode": "payment", + "success_url": f"{base}/reports?order={order['id']}", + "cancel_url": f"{base}/pricing?checkout=cancel", + "line_items[0][price]": report_price, + "line_items[0][quantity]": "1", + "customer_email": customer_email, + "client_reference_id": customer_email, + "metadata[email]": customer_email, + "metadata[product]": "quantradar_report", + "metadata[order_id]": order["id"], + "metadata[ticker]": order["ticker"], + "metadata[as_of]": order["as_of"], + "custom_text[submit][message]": f"{order['ticker']} report · snapshot as of {order['as_of']} · one-time payment.", + "payment_intent_data[metadata][order_id]": order["id"], + "payment_intent_data[metadata][product]": "quantradar_report", + } + bump_price = price_id_bump() + if with_bump and not bump_price: + raise ValueError("The CSV add-on price is not configured") + if with_bump and bump_price: + data["line_items[1][price]"] = bump_price + data["line_items[1][quantity]"] = "1" + data["metadata[bump]"] = "1" + body = urllib.parse.urlencode(data).encode() + req = urllib.request.Request( + "https://api.stripe.com/v1/checkout/sessions", + data=body, + headers={ + "Authorization": f"Bearer {secret}", + "Content-Type": "application/x-www-form-urlencoded", + "User-Agent": "QuantRadar-Stripe/0.5", + "Idempotency-Key": "report-checkout-" + order["id"], + }, + method="POST", + ) + try: + with urllib.request.urlopen(req, timeout=30) as resp: + obj = json.loads(resp.read().decode()) + except urllib.error.HTTPError as exc: + detail = exc.read().decode(errors="replace")[:800] + raise RuntimeError(f"stripe checkout failed: {exc.code} {detail}") from exc + from app import paid_delivery + paid_delivery.attach_checkout(order["id"], obj) + return {"id": obj.get("id"), "url": obj.get("url"), "product": "report", "order_id": order["id"]} + + +def create_credit_coupon(email: str, amount_cents: int = 900, *, order_id: str | None = None, paid_at: float | None = None) -> str | None: + """Once-only coupon crediting the $9 report toward Pro's first month. + + Expires in 7 days — the credit is a real, time-boxed incentive, and the + countdown shown to the buyer is truthful. + """ + secret = stripe_secret() + if not secret: + return None + if not order_id or paid_at is None: + raise ValueError("A paid order is required to issue report credit") + expires = int(paid_at) + 7 * 24 * 3600 + data = urllib.parse.urlencode( + { + "id": "qr-report-" + order_id, + "amount_off": str(amount_cents), + "currency": "usd", + "duration": "once", + "max_redemptions": "1", + "redeem_by": str(expires), + "name": "QuantRadar report credit", + "metadata[email]": email, + "metadata[order_id]": order_id, + } + ).encode() + req = urllib.request.Request( + "https://api.stripe.com/v1/coupons", + data=data, + headers={ + "Authorization": f"Bearer {secret}", + "Content-Type": "application/x-www-form-urlencoded", + "User-Agent": "QuantRadar-Stripe/0.5", + "Idempotency-Key": "report-credit-" + order_id, + }, + method="POST", + ) + try: + with urllib.request.urlopen(req, timeout=30) as resp: + obj = json.loads(resp.read().decode()) + return str(obj.get("id") or "") or None + except urllib.error.HTTPError as exc: + if exc.code in {400, 409}: + try: + existing = stripe_get("coupons/" + urllib.parse.quote("qr-report-" + order_id, safe="")) + if (existing.get("metadata") or {}).get("order_id") == order_id: + return str(existing["id"]) + except Exception: + pass + return None + except Exception: + return None + + +def coupon_redeemable(coupon_id: str | None) -> bool: + """True only if the coupon exists and Stripe would still accept it + (not expired by redeem_by, not exhausted max_redemptions).""" + secret = stripe_secret() + cid = (coupon_id or "").strip() + if not secret or not cid: + return False + req = urllib.request.Request( + f"https://api.stripe.com/v1/coupons/{cid}", + headers={"Authorization": f"Bearer {secret}"}, + ) + try: + with urllib.request.urlopen(req, timeout=30) as resp: + obj = json.loads(resp.read().decode()) + except Exception: + return False + if obj.get("valid") is False: + return False + redeem_by = obj.get("redeem_by") + if isinstance(redeem_by, (int, float)) and time.time() > redeem_by: + return False + max_red = obj.get("max_redemptions") + times = obj.get("times_redeemed") or 0 + if isinstance(max_red, int) and times >= max_red: + return False + return True + + +def revoke_credit_coupon(coupon_id: str | None) -> bool: + if not coupon_id: + return True + if not stripe_secret(): + return False + request = urllib.request.Request( + "https://api.stripe.com/v1/coupons/" + urllib.parse.quote(coupon_id, safe=""), + headers={"Authorization": "Bearer " + stripe_secret()}, method="DELETE") + try: + with urllib.request.urlopen(request, timeout=20): + return True + except urllib.error.HTTPError as exc: + return exc.code == 404 + except Exception: + return False + + +def pro_checkout_with_credit( + *, customer_email: str, interval: str = "monthly", coupon_id: str | None = None, + plan: str = "pro", +) -> dict[str, Any]: + return create_checkout_session( + customer_email=customer_email, interval=interval, plan=plan, + coupon_id=coupon_id if plan == "pro" else None, + ) + + def verify_webhook_signature(payload: bytes, sig_header: str | None, *, tolerance_sec: int = 300) -> bool: """Verify Stripe-Signature header (t=...,v1=...).""" secret = webhook_secret() @@ -205,61 +415,140 @@ def _plan_from_metadata(meta: dict[str, Any] | None) -> str: return plan_from_product(str(meta.get("product") or "")) -def apply_webhook_event(event: dict[str, Any]) -> dict[str, Any]: - """Apply plan changes from a verified Stripe event. Returns action summary.""" - from app.users import set_plan +def stripe_get(path: str) -> dict[str, Any]: + secret = stripe_secret() + if not secret: + raise RuntimeError("Stripe is not configured") + request = urllib.request.Request("https://api.stripe.com/v1/" + path, + headers={"Authorization": f"Bearer {secret}"}) + with urllib.request.urlopen(request, timeout=20) as response: + return json.loads(response.read().decode()) + + +def stripe_post(path: str, data: dict, *, idempotency_key: str) -> dict[str, Any]: + request = urllib.request.Request("https://api.stripe.com/v1/" + path, + data=urllib.parse.urlencode(data).encode(), method="POST", + headers={"Authorization": "Bearer " + stripe_secret(), "Content-Type": "application/x-www-form-urlencoded", + "Idempotency-Key": idempotency_key}) + with urllib.request.urlopen(request, timeout=20) as response: + return json.loads(response.read().decode()) + + +def create_billing_portal(email: str, *, plan: str | None = None, interval: str | None = None) -> dict: + from app import paid_delivery, users + account = users.get_user(email) or {} + with paid_delivery.database() as db: + row = db.execute("SELECT * FROM subscriptions WHERE owner=? AND status NOT IN ('canceled','incomplete_expired') ORDER BY updated_at DESC LIMIT 1", (users.normalize_email(email),)).fetchone() + customer = row["customer_id"] if row else account.get("stripe_customer_id") + if not customer: + raise ValueError("No Stripe subscription is linked to this account") + data = {"customer": str(customer), "return_url": public_base_url() + "/pricing"} + configuration = os.environ.get("STRIPE_PORTAL_CONFIGURATION_ID", "").strip() + if configuration: + data["configuration"] = configuration + if plan and row: + subscription = stripe_get("subscriptions/" + urllib.parse.quote(row["id"], safe="")) + items = (subscription.get("items") or {}).get("data") or [] + price = price_id_for_plan(plan, interval) + if not price: + raise ValueError("Selected plan is not configured") + if len(items) == 1 and items[0].get("id"): + data.update({"flow_data[type]": "subscription_update_confirm", + "flow_data[subscription_update_confirm][subscription]": row["id"], + "flow_data[subscription_update_confirm][items][0][id]": items[0]["id"], + "flow_data[subscription_update_confirm][items][0][price]": price, + "flow_data[subscription_update_confirm][items][0][quantity]": "1"}) + request = urllib.request.Request("https://api.stripe.com/v1/billing_portal/sessions", + data=urllib.parse.urlencode(data).encode(), + headers={"Authorization": "Bearer " + stripe_secret(), "Content-Type": "application/x-www-form-urlencoded"}, method="POST") + with urllib.request.urlopen(request, timeout=20) as response: + session = json.loads(response.read().decode()) + return {"id": session["id"], "url": session["url"], "billing_portal": True} + + +def _sync_subscription(db, subscription_id: str, *, expected_owner: str | None = None) -> dict[str, Any]: + # Read current Stripe state while the event transaction serializes handlers. + # Delivery order and event.created cannot reliably order subscription changes. + if not subscription_id.startswith("sub_"): + raise ValueError("subscription ID required") + subscription = stripe_get("subscriptions/" + urllib.parse.quote(subscription_id, safe="")) + metadata = subscription.get("metadata") or {} + known_products = {"quantradar_pro", "quantradar_portfolio_pro"} + items = (subscription.get("items") or {}).get("data") or [] + prices = {price_id_for_interval("monthly"): "pro", price_id_for_interval("yearly"): "pro", + price_id_for_plan("portfolio_pro"): "portfolio_pro"} + prices.pop("", None) + if metadata.get("product") not in known_products and not any( + (item.get("price", {}).get("id") if isinstance(item.get("price"), dict) else item.get("price")) in prices for item in items + ): + return {"ok": True, "action": "ignored", "reason": "unrelated_product"} + if len(items) != 1: + return {"ok": False, "error": "unsupported_subscription_items"} + price = items[0].get("price") or {} + price_id = price.get("id") if isinstance(price, dict) else price + plan = prices.get(price_id) + if plan is None: + return {"ok": False, "error": "unrecognized_subscription_price"} + from app.users import normalize_email, find_email_by_stripe_customer + customer = subscription.get("customer") + customer = customer.get("id") if isinstance(customer, dict) else customer + prior = db.execute("SELECT owner FROM subscriptions WHERE id=?", (subscription_id,)).fetchone() + email = metadata.get("email") or (prior["owner"] if prior else None) or find_email_by_stripe_customer(customer) or expected_owner + if not email: + return {"ok": False, "error": "no_email"} + email = normalize_email(email) + if expected_owner and email != normalize_email(expected_owner): + raise ValueError("Subscription owner does not match the checkout account") + previously_active = db.execute("SELECT 1 FROM subscriptions WHERE owner=? AND status IN ('active','trialing') AND paid_through>? LIMIT 1", (email, time.time())).fetchone() is not None + paid_through = subscription.get("current_period_end") or items[0].get("current_period_end") or subscription.get("trial_end") or 0 + status = str(subscription.get("status") or "unknown") + db.execute("""INSERT INTO subscriptions VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET + owner=excluded.owner,customer_id=excluded.customer_id,plan=excluded.plan,price_id=excluded.price_id, + status=excluded.status,paid_through=excluded.paid_through,updated_at=excluded.updated_at""", + (subscription_id, email, customer, plan, price_id, status, float(paid_through), time.time())) + if metadata.get("checkout_attempt"): + db.execute("UPDATE subscription_checkouts SET state='complete' WHERE owner=? AND id=?", (email, metadata["checkout_attempt"])) + effective = {row[0] for row in db.execute("SELECT plan FROM subscriptions WHERE owner=? AND status IN ('active','trialing') AND paid_through>?", (email, time.time()))} + plan = "portfolio_pro" if "portfolio_pro" in effective else "pro" if "pro" in effective else "free" + return {"ok": True, "action": "plan_" + plan, "plan": plan, "email": email, "customer_id": customer, + "activated": not previously_active and plan != "free"} + +def apply_webhook_event(event: dict[str, Any]) -> dict[str, Any]: + """Only verified events enter here; persist each effect once on durable storage.""" + from app import paid_delivery etype = str(event.get("type") or "") - data_obj = (event.get("data") or {}).get("object") or {} - if not isinstance(data_obj, dict): + obj = (event.get("data") or {}).get("object") or {} + if not isinstance(obj, dict): return {"ok": False, "error": "bad_event_object", "type": etype} - if etype == "checkout.session.completed": - email = _email_from_checkout_session(data_obj) - if not email: - return {"ok": False, "error": "no_email", "type": etype} - payment_status = str(data_obj.get("payment_status") or "").strip().lower() - if payment_status not in {"paid", "no_payment_required"}: - return { - "ok": False, - "error": "not_paid", - "type": etype, - "status": payment_status or "missing", - } - meta = data_obj.get("metadata") if isinstance(data_obj.get("metadata"), dict) else {} - plan_n = _plan_from_metadata(meta) - customer_id = data_obj.get("customer") - if isinstance(customer_id, dict): - customer_id = customer_id.get("id") - user = set_plan( - email, - plan_n, - stripe_customer_id=str(customer_id) if customer_id else None, - ) - action = "plan_portfolio_pro" if plan_n == "portfolio_pro" else "plan_pro" - return {"ok": True, "action": action, "email": email, "user": user, "type": etype, "plan": plan_n} - - if etype in { - "customer.subscription.deleted", - "customer.subscription.paused", - }: - from app.users import find_email_by_stripe_customer - - email = None - meta = data_obj.get("metadata") if isinstance(data_obj.get("metadata"), dict) else {} - if meta.get("email"): - email = str(meta["email"]).strip().lower() - # Fallback: customer_email not always present on subscription objects - if not email and data_obj.get("customer_email"): - email = str(data_obj["customer_email"]).strip().lower() - customer_id = data_obj.get("customer") - if isinstance(customer_id, dict): - customer_id = customer_id.get("id") - if not email and customer_id: - email = find_email_by_stripe_customer(str(customer_id)) - if not email: - return {"ok": False, "error": "no_email", "type": etype} - user = set_plan(email, "free") - return {"ok": True, "action": "plan_free", "email": email, "user": user, "type": etype} - - return {"ok": True, "action": "ignored", "type": etype} + def apply(db): + if etype in {"checkout.session.completed", "checkout.session.async_payment_succeeded"}: + metadata = obj.get("metadata") or {} + product = metadata.get("product") + if product not in {"quantradar_report", "quantradar_pro", "quantradar_portfolio_pro"}: + return {"ok": True, "action": "ignored", "reason": "unrelated_product"} + if obj.get("payment_status") not in {"paid", "no_payment_required"}: + return {"ok": True, "action": "awaiting_payment"} + if product == "quantradar_report": + return paid_delivery.mark_report_paid(db, obj, paid_at=event.get("created")) + if obj.get("mode") != "subscription": + return {"ok": False, "error": "wrong_checkout_mode"} + return _sync_subscription(db, str(obj.get("subscription") or "")) + if etype.startswith("customer.subscription."): + return _sync_subscription(db, str(obj.get("id") or "")) + if etype in {"invoice.paid", "invoice.payment_failed", "invoice.payment_action_required"}: + subscription_id = obj.get("subscription") or ((obj.get("parent") or {}).get("subscription_details") or {}).get("subscription") + if subscription_id: + return _sync_subscription(db, str(subscription_id)) + if etype == "charge.refunded": + return paid_delivery.record_refund(db, obj) + if etype in {"checkout.session.expired", "checkout.session.async_payment_failed"}: + db.execute("UPDATE report_orders SET payment_state='expired' WHERE checkout_id=? AND payment_state='unpaid'", (obj.get("id"),)) + return {"ok": True, "action": "ignored", "type": etype} + + result = paid_delivery.event_once(str(event.get("id") or ""), etype, apply) + if result.get("ok") and result.get("action", "").startswith("plan_") and not result.get("duplicate"): + from app.users import set_plan + set_plan(result["email"], result["plan"], stripe_customer_id=result.get("customer_id")) + return result diff --git a/app/subscription_checkout.py b/app/subscription_checkout.py new file mode 100644 index 0000000..f7a8435 --- /dev/null +++ b/app/subscription_checkout.py @@ -0,0 +1,179 @@ +"""One recoverable subscription checkout per account, across clicks and restarts.""" + +from __future__ import annotations + +import time +import uuid +import urllib.parse + +from app import paid_delivery, stripe_billing as stripe, users + + +class CouponRejected(Exception): + pass + + +def _reconcile_existing(owner: str, customer: str): + """Legacy customers may have paid before the local subscription ledger existed.""" + prices = {stripe.price_id_for_plan("pro", "monthly"), stripe.price_id_for_plan("pro", "yearly"), stripe.price_id_for_plan("portfolio_pro")} + prices.discard("") + path = "subscriptions?customer=" + urllib.parse.quote(customer, safe="") + "&status=all&limit=100" + for _ in range(20): + page = stripe.stripe_get(path) + for subscription in page["data"]: + related = (subscription.get("metadata") or {}).get("product") in {"quantradar_pro", "quantradar_portfolio_pro"} + related = related or any((item.get("price") or {}).get("id") in prices for item in (subscription.get("items") or {}).get("data", [])) + if related and subscription.get("status") not in {"canceled", "incomplete_expired"}: + with paid_delivery.database() as db: + db.execute("BEGIN IMMEDIATE") + result = stripe._sync_subscription(db, subscription["id"], expected_owner=owner) + if not result.get("ok") or result.get("email") != owner: + raise RuntimeError("Existing subscription reconciliation is incomplete") + if not page.get("has_more"): + return + path = path.split("&starting_after=")[0] + "&starting_after=" + urllib.parse.quote(page["data"][-1]["id"], safe="") + raise RuntimeError("Existing subscriptions could not be fully reconciled") + + +def _customer(owner: str) -> str: + existing = (users.get_user(owner) or {}).get("stripe_customer_id") + with paid_delivery.database() as db: + db.execute("INSERT OR IGNORE INTO stripe_customers VALUES(?,?,?)", (owner, uuid.uuid4().hex, existing)) + row = db.execute("SELECT * FROM stripe_customers WHERE owner=?", (owner,)).fetchone() + if row["customer_id"]: + return row["customer_id"] + customer = stripe.stripe_post("customers", {"email": owner, "metadata[product]": "quantradar"}, + idempotency_key="qr-customer-" + row["request_id"]) + if not str(customer.get("id", "")).startswith("cus_"): + raise RuntimeError("Stripe customer creation is incomplete") + with paid_delivery.database() as db: + db.execute("UPDATE stripe_customers SET customer_id=? WHERE owner=? AND customer_id IS NULL", (customer["id"], owner)) + return db.execute("SELECT customer_id FROM stripe_customers WHERE owner=?", (owner,)).fetchone()[0] + + +def _current_attempt(owner: str, plan: str, interval: str, price: str, coupon: str | None, customer: str): + with paid_delivery.database() as db: + db.execute("BEGIN IMMEDIATE") + if db.execute("SELECT 1 FROM subscriptions WHERE owner=? AND status NOT IN ('canceled','incomplete_expired') LIMIT 1", (owner,)).fetchone(): + return None + row = db.execute("SELECT * FROM subscription_checkouts WHERE owner=?", (owner,)).fetchone() + if row is None or row["state"] == "closed": + db.execute("""INSERT INTO subscription_checkouts(owner,id,plan,interval,price_id,coupon_id,customer_id,created_at) + VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(owner) DO UPDATE SET + id=excluded.id,plan=excluded.plan,interval=excluded.interval,price_id=excluded.price_id, + coupon_id=excluded.coupon_id,customer_id=excluded.customer_id,checkout_id=NULL,checkout_url=NULL, + state='creating',created_at=excluded.created_at""", + (owner, "qr-sub-" + uuid.uuid4().hex, plan, interval, price, coupon, customer, time.time())) + row = db.execute("SELECT * FROM subscription_checkouts WHERE owner=?", (owner,)).fetchone() + return dict(row) + + +def _recover_session(attempt: dict) -> dict: + path = "checkout/sessions?customer=" + urllib.parse.quote(attempt["customer_id"], safe="") + "&limit=100" + for _ in range(20): + page = stripe.stripe_get(path) + for session in page["data"]: + if (session.get("metadata") or {}).get("checkout_attempt") == attempt["id"]: + return session + if not page.get("has_more"): + break + path = path.split("&starting_after=")[0] + "&starting_after=" + urllib.parse.quote(page["data"][-1]["id"], safe="") + raise ValueError("A previous checkout needs reconciliation. Please contact support; no new payment was started.") + + +def revoke_coupon_checkouts(coupon_id: str) -> None: + """Finish revocation without creating a checkout or changing a paid subscription.""" + with paid_delivery.database() as db: + attempts = [dict(row) for row in db.execute( + "SELECT * FROM subscription_checkouts WHERE coupon_id=? AND state!='closed'", (coupon_id,))] + for attempt in attempts: + session = (stripe.stripe_get("checkout/sessions/" + urllib.parse.quote(attempt["checkout_id"], safe="")) + if attempt["checkout_id"] else _recover_session(attempt)) + if session.get("status") == "open": + session = stripe.stripe_post("checkout/sessions/" + urllib.parse.quote(session["id"], safe="") + "/expire", {}, + idempotency_key="expire-" + attempt["id"]) + if session.get("status") not in {"expired", "complete"}: + raise ValueError("Discounted checkout revocation is pending") + with paid_delivery.database() as db: + db.execute("UPDATE subscription_checkouts SET checkout_id=?,checkout_url=?,state=? WHERE owner=? AND id=?", + (session["id"], session.get("url"), "closed" if session["status"] == "expired" else "complete", + attempt["owner"], attempt["id"])) + + +def _session(attempt: dict) -> dict: + if attempt["checkout_id"]: + return stripe.stripe_get("checkout/sessions/" + urllib.parse.quote(attempt["checkout_id"], safe="")) + # Stripe may prune idempotency keys after 24h. Never blindly recreate an old uncertain result. + if time.time() - attempt["created_at"] >= 23 * 3600: + return _recover_session(attempt) + try: + session = stripe.create_checkout_session(customer_email=attempt["owner"], customer_id=attempt["customer_id"], + price_id=attempt["price_id"], plan=attempt["plan"], interval=attempt["interval"], + coupon_id=attempt["coupon_id"], idempotency_key=attempt["id"]) + except stripe.StripeRequestError as error: + if not error.coupon_rejected or not attempt["coupon_id"]: + raise + with paid_delivery.database() as db: + db.execute("UPDATE subscription_checkouts SET state='closed' WHERE owner=? AND id=? AND checkout_id IS NULL", (attempt["owner"], attempt["id"])) + raise CouponRejected from error + if not session.get("id") or not session.get("url"): + raise RuntimeError("Checkout creation is incomplete. Retry to recover the same checkout.") + with paid_delivery.database() as db: + updated = db.execute("UPDATE subscription_checkouts SET checkout_id=?,checkout_url=?,state=CASE WHEN state='complete' THEN state ELSE 'open' END WHERE owner=? AND id=?", + (session["id"], session["url"], attempt["owner"], attempt["id"])) + if updated.rowcount != 1: + raise ValueError("Checkout changed in another window. Please retry.") + # Fetch authoritative state: a lost response can hide a completed payment. + return stripe.stripe_get("checkout/sessions/" + urllib.parse.quote(session["id"], safe="")) + + +def start(owner: str, *, plan: str, interval: str, coupon_id: str | None = None) -> dict: + owner = users.normalize_email(owner) + plan = stripe.normalize_checkout_plan(plan) + interval = "yearly" if plan == "pro" and interval.lower() in {"year", "yearly", "annual", "annually"} else "monthly" + price = stripe.price_id_for_plan(plan, interval) + if not price: + raise ValueError("This plan is temporarily unavailable") + customer = _customer(owner) + with paid_delivery.database() as db: + prior = db.execute("SELECT state FROM subscription_checkouts WHERE owner=?", (owner,)).fetchone() + if prior is None or prior["state"] == "closed": + _reconcile_existing(owner, customer) + for _ in range(3): + attempt = _current_attempt(owner, plan, interval, price, coupon_id if plan == "pro" else None, customer) + if attempt is None: + return stripe.create_billing_portal(owner, plan=plan, interval=interval) + try: + session = _session(attempt) + except CouponRejected: + coupon_id = paid_delivery.report_credit(owner) + continue + status = session.get("status") + if status == "complete": + subscription = session.get("subscription") + if not subscription: + raise ValueError("Your payment is being confirmed. Please retry shortly; no second subscription was started.") + with paid_delivery.database() as db: + db.execute("BEGIN IMMEDIATE") + result = stripe._sync_subscription(db, str(subscription), expected_owner=owner) + if not result.get("ok") or result.get("email") != owner or not result.get("action", "").startswith("plan_"): + raise RuntimeError("Subscription confirmation is pending") + if paid_delivery.has_open_subscription(owner): + return stripe.create_billing_portal(owner, plan=plan, interval=interval) + status = "expired" # A completed checkout is not payable again after cancellation. + if status == "open": + # A refund can revoke a credit while Stripe creates or recovers this session. + coupon_id = paid_delivery.report_credit(owner) if plan == "pro" else None + if status == "open" and (attempt["plan"], attempt["interval"], attempt["price_id"], attempt["coupon_id"]) == (plan, interval, price, coupon_id): + if not session.get("url"): + raise RuntimeError("Checkout URL is unavailable") + return {"id": session["id"], "url": session["url"], "plan": plan, "interval": interval} + if status == "open": + expired = stripe.stripe_post("checkout/sessions/" + urllib.parse.quote(session["id"], safe="") + "/expire", {}, + idempotency_key="expire-" + attempt["id"]) + status = expired.get("status") + if status != "expired": + raise ValueError("Previous checkout status is unresolved. Please retry; no new payment was started.") + with paid_delivery.database() as db: + db.execute("UPDATE subscription_checkouts SET state='closed' WHERE owner=? AND id=?", (owner, attempt["id"])) + raise ValueError("Checkout changed in another window. Please retry.") diff --git a/app/users.py b/app/users.py index e663e74..f78b073 100644 --- a/app/users.py +++ b/app/users.py @@ -112,6 +112,11 @@ def public_user(u: dict[str, Any]) -> dict[str, Any]: "name": u.get("name") or None, "plan": u.get("plan") or "free", "created_at": u.get("created_at"), + "watchlist": [str(t).upper() for t in (u.get("watchlist") or [])], + "report_granted": bool(u.get("report_granted")), + "bump_csv_priority": bool(u.get("bump_csv_priority")), + "daily_digest": bool(u.get("daily_digest")), + "report_coupon": u.get("report_coupon") or None, } @@ -272,6 +277,10 @@ def resolve_plan(email: str | None, *, session_plan: str | None = None) -> str: u = get_user(email) if not u: return "free" + from app.paid_delivery import subscription_plan + billed_plan = subscription_plan(email) + if billed_plan is not None: + return billed_plan plan = str(u.get("plan") or "free").strip().lower() return plan if plan in VALID_PLANS else "free" @@ -313,6 +322,37 @@ def set_plan( return public_user(u) +def grant_report(email: str, *, bump: bool = False) -> dict[str, Any]: + """Grant the one-time $9 deep report entitlement (and $5 bump if taken).""" + email_n = normalize_email(email) + with _LOCK: + store = _load() + u = store["users"].get(email_n) + if not isinstance(u, dict): + raise ValueError("no account") + u = dict(u) + u["report_granted"] = True + u["report_granted_at"] = time.time() + if bump: + u["bump_csv_priority"] = True + store["users"][email_n] = u + _save(store) + return public_user(u) + + +def set_report_coupon(email: str, coupon_id: str | None) -> None: + """Remember the once-only $9→Pro credit coupon id for this account.""" + email_n = normalize_email(email) + with _LOCK: + store = _load() + u = store["users"].get(email_n) + if isinstance(u, dict): + u = dict(u) + u["report_coupon"] = coupon_id + store["users"][email_n] = u + _save(store) + + def find_email_by_stripe_customer(customer_id: str | None) -> str | None: """Look up email for a Stripe customer id (cancel webhook fallback).""" cid = (customer_id or "").strip() diff --git a/app/watch_reports.py b/app/watch_reports.py new file mode 100644 index 0000000..4576a47 --- /dev/null +++ b/app/watch_reports.py @@ -0,0 +1,140 @@ +"""Account-owned daily watchlist snapshots, with recoverable per-ticker work.""" + +from __future__ import annotations + +import csv +import io +import json +import time +import uuid + +from app import engagement, paid_delivery, users +from free_engine.market_calendar import completed_session + + +def request_report(owner: str) -> str: + owner = users.normalize_email(owner) + plan = users.resolve_plan(owner) + if not users.is_paid_plan(plan): + raise ValueError("Pro is required to create daily watchlist reports") + cutoff = completed_session() + if cutoff is None: + raise ValueError("Market calendar coverage is unavailable") + roster = engagement.get_watchlist(owner)[:engagement.WATCH_LIMITS[plan]] + if not roster: + raise ValueError("Add a ticker to your watchlist first") + with paid_delivery.database() as db: + db.execute("""INSERT OR IGNORE INTO watch_reports + (id,owner,as_of,roster,created_at,csv_enabled) VALUES(?,?,?,?,?,?)""", + (uuid.uuid4().hex, owner, cutoff, json.dumps(roster), time.time(), int(plan == "portfolio_pro"))) + return db.execute("SELECT id FROM watch_reports WHERE owner=? AND as_of=?", (owner, cutoff)).fetchone()[0] + + +def schedule_optins(): + for account in engagement.digest_optins(): + if users.is_paid_plan(users.resolve_plan(account["email"])): + try: + request_report(account["email"]) + except ValueError: + pass + + +def _public(row) -> dict: + results = json.loads(row["results"]) + roster = json.loads(row["roster"]) + return { + "id": row["id"], "as_of": row["as_of"], "created_at": row["created_at"], + "state": row["state"], "tickers": roster, "total": len(roster), + "processed": len(results), "ready": sum(r["status"] == "ready" for r in results.values()), + "csv_enabled": bool(row["csv_enabled"]), + "rows": [{k: v for k, v in results[ticker].items() if k != "attempts"} + for ticker in roster if ticker in results], + "note": "A daily watchlist snapshot, not portfolio returns or trade recommendations. Changes compare prior saved snapshots. Missing data remains UNKNOWN.", + } + + +def list_reports(owner: str) -> list[dict]: + with paid_delivery.database() as db: + return [_public(row) for row in db.execute("SELECT * FROM watch_reports WHERE owner=? ORDER BY as_of DESC LIMIT 30", (users.normalize_email(owner),))] + + +def get_report(owner: str, report_id: str) -> dict | None: + with paid_delivery.database() as db: + row = db.execute("SELECT * FROM watch_reports WHERE owner=? AND id=?", (users.normalize_email(owner), report_id)).fetchone() + return _public(row) if row else None + + +def csv_export(report: dict) -> str: + output = io.StringIO(newline="") + fields = ("ticker", "as_of", "status", "close", "score", "action", "market_gate", "previous_action", "changed", "reliability", "note") + writer = csv.DictWriter(output, fieldnames=fields, extrasaction="ignore") + writer.writeheader() + writer.writerows(report["rows"]) + return output.getvalue() + + +def process_next(*, now: float | None = None) -> bool: + from app.charts_facade import run_fetch_all + from app.quality import assess_charts_payload + + now = time.time() if now is None else now + with paid_delivery.database() as db: + db.execute("BEGIN IMMEDIATE") + job = db.execute("""SELECT * FROM watch_reports WHERE state IN ('queued','building','retrying') + AND retry_at<=? AND lease_until<=? ORDER BY created_at LIMIT 1""", (now, now)).fetchone() + if job is None: + return False + roster, results = json.loads(job["roster"]), json.loads(job["results"]) + candidates = [t for t in roster if t not in results] or [t for t in roster if results[t]["status"] != "ready" and results[t]["attempts"] < 3] + if not candidates: + state = "ready" if all(r["status"] == "ready" for r in results.values()) else "partial" + db.execute("UPDATE watch_reports SET state=?,lease_until=0,lease_token=NULL WHERE id=?", (state, job["id"])) + return True + ticker = candidates[0] + attempt = results.get(ticker, {}).get("attempts", 0) + 1 + results[ticker] = {**results.get(ticker, {}), "ticker": ticker, "as_of": job["as_of"], + "status": "unavailable", "action": "UNKNOWN", "score": None, + "note": "Data fetch is pending or interrupted.", "attempts": attempt} + lease_token = uuid.uuid4().hex + db.execute("UPDATE watch_reports SET state='building',lease_until=?,lease_token=?,results=? WHERE id=?", + (now + 120, lease_token, json.dumps(results), job["id"])) + previous = db.execute("SELECT results FROM watch_reports WHERE owner=? AND as_of 2026-07-12 定版。之后部署/改版只认本文件，避免 Manus / 仓库 / 线上三套混谈。 +核验日期：2026-09-06。此文件取代此前的 Render / Manus 部署说明。 -## 1. 唯一权威源（SSOT） +## 当前生产 -| 项 | 值 | -|----|-----| -| 代码 | `https://github.com/Alexaliao001/quantradar` **main** | -| 当前基线 | `d8132cc` · **v0.6.0**（path-C 壳 + 邮箱密码登录 + Trust Gate） | -| 引擎 | `~/charts`（stock-charts），壳**不算**分、不抄 generate_charts | -| **不是**权威 | Manus 任务里的旧 SPA、Manus 独有 diff、trycloudflare 临时隧道 | +| 项目 | 已核验值 | +|---|---| +| 代码仓库 | https://github.com/Alexaliao001/quantradar | +| 网站 | https://quantradar.one ，www 同源 | +| 主机 | Nube VPS，SSH alias `nube-sin` | +| Web 进程 | systemd `quantradar`，`www-data`，Python 3.12 `python3 -m app` | +| 工作目录 | `/opt/nube-sites/apps/quantradar` | +| 线上独立引擎目录 | `/opt/nube-sites/apps/charts-engine`，由 `CHARTS_DIR` 指定 | +| 环境 | `/opt/nube-sites/secrets/quantradar.env`；不进入 Git、日志或报告 | +| 代理 | Caddy → `127.0.0.1:8765` | +| 数据 | 工作目录的 `data/`；新版本增加 `billing.sqlite3`（WAL） | +| 目前线上 health | v0.7.0，git_sha=null，live；尚未发布本次修复 | -```text -写代码 → 只改本机仓库 → 本机打磨（docs/LOCAL_POLISH.md） - → commit + push GitHub main -跑线上 → Render Blueprint / Docker 自部署（docs/SELF_DEPLOY.md） -域名 → DNS 指向 Render（GlobalDomain / Cloudflare） -禁止 → Manus 当运行时 / Manus pull 发布 / Manus agent 修产品 -``` +`git_sha=null` 无法证明线上等于某个提交。待发布包加入 `SOURCE_HEAD` 后，必须核对本机提交、包清单和线上 health 三者一致。无需变更 DNS。 -## 2. 明确：线上 ≠ 仓库 +## 当前发布前条件 -| 表面 | 是什么 | 是否最新仓库 | -|------|--------|--------------| -| GitHub main | Grok 建设的 path-C 壳 | ✅ 是 | -| `127.0.0.1:8765` | 本地 `python -m app` | ✅ 应与仓库一致 | -| `quantradar.one` | Manus 旧 SPA（tRPC / app-auth / 假统计） | ❌ **不是** | +1. 数据许可须覆盖网页、iOS、计算结果及拟出售的 JSON/CSV 下载。公开 API 可访问不等于已有商用授权；见 `DATA_LICENSING.md`。 +2. Stripe 测试环境必须验证实际结账、签名 webhook、交付、退款、续费、取消、计划切换。本轮已通过真实 sandbox 验收，见 `docs/audit/2026-09-06/stripe-sandbox.json`。`scripts/audit_billing.py` 拒绝 live key，仅验证金额；生命周期另由浏览器、签名事件和 Test Clock 验证。 +3. 正式账户核对遗留 Payment Links、价格、Portal 和 webhook。Portfolio Pro 价格尚未接入，禁止仅靠页面展示宣称可购买。 +4. 完成 Python 隔离测试、iOS 测试、375/1440 页面验收、签名归档检查。 -验收是否 cutover 成功，只看： +已准备独立正式 Portal `bpc_1UCTPA7uBhbslGrGuE1dZAda`，不是默认配置，尚未写入生产环境。允许 Pro 月/年、Portfolio 月切换，差额即时开票，期末取消。正式环境应通过 `STRIPE_PORTAL_CONFIGURATION_ID` 明确选择它。当前 webhook `we_1U6uvl7uBhbslGrG01EauQuf` 仍只有四种旧事件；须随新版一同补全事件配置，不能将已创建 Portal 当作已完成生产接线。 -```bash -curl -sS https://quantradar.one/health -# 必须： "service":"quantradar-shell" 且 "manus_login":false -# 且 version/git_sha 对齐 GitHub main -``` +## 发布步骤 -## 3. 最正确部署路径（默认走这条） +1. `python3 scripts/test_isolated.py`；生产或真实账户目录不要直接运行 unittest。 +2. 提交并推送经复核的源码。`python3 scripts/package_release.py /absolute/private/output-directory` 只打包已提交的运行文件，拒绝脏工作区；包里不含 `.env`、`data`、缓存或 iOS 签名材料。 +3. 上传至 `/opt/nube-sites/releases/quantradar-- Own account — email + password. No Manus. - Guest demo radar stays open without signing in. + Save your watchlist and keep your reports in one place. + You can also run free scans without an account.
-