423 lines
16 KiB
Python
423 lines
16 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
Auto-provision Stripe Products and Prices from the built-in plan catalog.
|
|
|
|
Creates separate Stripe Products for user licenses and modules
|
|
so that invoice line items show clear, descriptive names:
|
|
- "Benutzer-Lizenzen"
|
|
- "Module"
|
|
|
|
Idempotent — safe to call on every startup.
|
|
|
|
Source of truth for unit amounts is BUILTIN_PLANS (CHF). On each run, persisted
|
|
Stripe Price IDs are reconciled: if Stripe's unit_amount differs from the
|
|
catalog, a new Price is created, the old one is archived, and poweron_billing
|
|
StripePlanPrice is updated. Other stale active Prices on the same Product
|
|
(same recurring interval) are archived so only the catalog-matching Price stays active.
|
|
"""
|
|
|
|
import logging
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from typing import Dict, Optional
|
|
|
|
from modules.connectors.connectorDbPostgre import DatabaseConnector
|
|
from modules.shared.configuration import APP_CONFIG
|
|
from modules.datamodels.datamodelSubscription import (
|
|
BUILTIN_PLANS,
|
|
SubscriptionPlan,
|
|
BillingPeriodEnum,
|
|
StripePlanPrice,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_BILLING_DATABASE = "poweron_billing"
|
|
_METADATA_KEY = "poweron_plan_key"
|
|
_METADATA_LINE_TYPE = "poweron_line_type"
|
|
|
|
_PERIOD_TO_STRIPE = {
|
|
BillingPeriodEnum.MONTHLY: {"interval": "month", "interval_count": 1},
|
|
BillingPeriodEnum.YEARLY: {"interval": "year", "interval_count": 1},
|
|
}
|
|
|
|
|
|
def _getBillingDb() -> DatabaseConnector:
|
|
return DatabaseConnector(
|
|
dbDatabase=_BILLING_DATABASE,
|
|
dbHost=APP_CONFIG.get("DB_HOST", "localhost"),
|
|
dbPort=int(APP_CONFIG.get("DB_PORT", "5432")),
|
|
dbUser=APP_CONFIG.get("DB_USER"),
|
|
dbPassword=APP_CONFIG.get("DB_PASSWORD_SECRET"),
|
|
)
|
|
|
|
|
|
def _loadExistingMappings(db: DatabaseConnector) -> Dict[str, StripePlanPrice]:
|
|
try:
|
|
rows = db.getRecordset(StripePlanPrice)
|
|
result = {}
|
|
for row in rows:
|
|
pk = row.get("planKey")
|
|
if pk:
|
|
result[pk] = StripePlanPrice(**{k: v for k, v in row.items() if not k.startswith("_")})
|
|
return result
|
|
except Exception as e:
|
|
logger.warning("Could not load StripePlanPrice records: %s", e)
|
|
return {}
|
|
|
|
|
|
def _findStripeProduct(stripe, planKey: str, lineType: str) -> Optional[str]:
|
|
"""Search Stripe for a product tagged with plan key + line type."""
|
|
try:
|
|
products = stripe.Product.search(
|
|
query=f'metadata["{_METADATA_KEY}"]:"{planKey}" AND metadata["{_METADATA_LINE_TYPE}"]:"{lineType}"',
|
|
limit=1,
|
|
)
|
|
if products.data:
|
|
return products.data[0].id
|
|
except Exception:
|
|
try:
|
|
products = stripe.Product.search(
|
|
query=f'metadata["{_METADATA_KEY}"]:"{planKey}"',
|
|
limit=10,
|
|
)
|
|
for p in products.data:
|
|
meta = p.get("metadata") or {}
|
|
if meta.get(_METADATA_LINE_TYPE) == lineType:
|
|
return p.id
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def _createStripeProduct(stripe, name: str, description: str, planKey: str, lineType: str) -> str:
|
|
product = stripe.Product.create(
|
|
name=name,
|
|
description=description,
|
|
metadata={_METADATA_KEY: planKey, _METADATA_LINE_TYPE: lineType},
|
|
)
|
|
logger.info("Created Stripe Product %s: %s (%s/%s)", product.id, name, planKey, lineType)
|
|
return product.id
|
|
|
|
|
|
def _recurringMatches(recurring: Dict, interval: str, intervalCount: int) -> bool:
|
|
if not recurring:
|
|
return False
|
|
if recurring.get("interval") != interval:
|
|
return False
|
|
ic = recurring.get("interval_count")
|
|
if ic is None:
|
|
ic = 1
|
|
return int(ic) == int(intervalCount)
|
|
|
|
|
|
def _findExistingStripePrice(
|
|
stripe, productId: str, unitAmount: int, interval: str, intervalCount: int = 1,
|
|
) -> Optional[str]:
|
|
try:
|
|
prices = stripe.Price.list(product=productId, active=True, limit=50)
|
|
for p in prices.data:
|
|
recurring = p.get("recurring") or {}
|
|
if p.get("unit_amount") == unitAmount and _recurringMatches(recurring, interval, intervalCount):
|
|
return p.id
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def _reconcilePrice(
|
|
stripe,
|
|
productId: str,
|
|
oldPriceId: str,
|
|
expectedCHF: float,
|
|
interval: str,
|
|
nickname: str,
|
|
intervalCount: int = 1,
|
|
) -> str:
|
|
"""If the stored Stripe Price has a different amount, is no longer active,
|
|
or has a different recurring interval, create/find a new active one and
|
|
deactivate the old."""
|
|
from modules.shared.stripeClient import stripeToDict
|
|
|
|
expectedCents = int(round(expectedCHF * 100))
|
|
actualCents: Optional[int] = None
|
|
matchesRecurring = False
|
|
isActive = False
|
|
retrieveFailed = False
|
|
try:
|
|
raw = stripe.Price.retrieve(oldPriceId)
|
|
pd = stripeToDict(raw)
|
|
actualCents = pd.get("unit_amount")
|
|
matchesRecurring = _recurringMatches(pd.get("recurring") or {}, interval, intervalCount)
|
|
# Stripe.Price.retrieve returns archived prices too, so we MUST check
|
|
# `active` explicitly. Subscription.create rejects inactive prices with
|
|
# "The price specified is inactive. This field only accepts active prices."
|
|
isActive = bool(pd.get("active"))
|
|
except Exception as ex:
|
|
retrieveFailed = True
|
|
logger.warning("Could not retrieve Stripe Price %s: %s", oldPriceId, ex)
|
|
|
|
if not retrieveFailed and isActive and actualCents == expectedCents and matchesRecurring:
|
|
return oldPriceId
|
|
|
|
logger.warning(
|
|
"Rotating Stripe Price %s on product %s: active=%s amount=%s (expected %s) recurringMatches=%s retrieveFailed=%s.",
|
|
oldPriceId, productId, isActive, actualCents, expectedCents, matchesRecurring, retrieveFailed,
|
|
)
|
|
|
|
existingMatch = _findExistingStripePrice(stripe, productId, expectedCents, interval, intervalCount)
|
|
if existingMatch:
|
|
newPriceId = existingMatch
|
|
else:
|
|
newPriceId = _createStripePrice(
|
|
stripe, productId, expectedCHF, interval, nickname, intervalCount,
|
|
)
|
|
|
|
try:
|
|
stripe.Price.modify(oldPriceId, active=False)
|
|
logger.info("Deactivated old Stripe Price %s", oldPriceId)
|
|
except Exception as e:
|
|
logger.warning("Could not deactivate old price %s: %s", oldPriceId, e)
|
|
|
|
return newPriceId
|
|
|
|
|
|
def _createStripePrice(
|
|
stripe, productId: str, unitAmountCHF: float, interval: str, nickname: str, intervalCount: int = 1,
|
|
) -> str:
|
|
price = stripe.Price.create(
|
|
product=productId,
|
|
unit_amount=int(round(unitAmountCHF * 100)),
|
|
currency="chf",
|
|
recurring={"interval": interval, "interval_count": intervalCount},
|
|
nickname=nickname,
|
|
)
|
|
logger.info("Created Stripe Price %s (%s, %s CHF/%s)", price.id, nickname, unitAmountCHF, interval)
|
|
return price.id
|
|
|
|
|
|
def _archiveOtherRecurringPrices(
|
|
stripe, productId: Optional[str], keepPriceId: Optional[str], interval: str, intervalCount: int = 1,
|
|
) -> None:
|
|
"""Archive every other active recurring price on the product (same interval pattern)."""
|
|
if not productId or not keepPriceId:
|
|
return
|
|
try:
|
|
prices = stripe.Price.list(product=productId, active=True, limit=100)
|
|
for p in prices.data:
|
|
if p.id == keepPriceId:
|
|
continue
|
|
recurring = p.get("recurring") or {}
|
|
if not recurring:
|
|
continue
|
|
if not _recurringMatches(recurring, interval, intervalCount):
|
|
continue
|
|
try:
|
|
stripe.Price.modify(p.id, active=False)
|
|
logger.info("Archived stale Stripe Price %s on product %s", p.id, productId)
|
|
except Exception as ex:
|
|
logger.warning("Could not archive price %s: %s", p.id, ex)
|
|
except Exception as e:
|
|
logger.warning("Stale price archive pass failed for product %s: %s", productId, e)
|
|
|
|
|
|
def _validateStripeIdsExist(stripe, mapping: StripePlanPrice) -> bool:
|
|
"""Quick check whether the stored Stripe product IDs still exist.
|
|
|
|
Returns False when running against a different Stripe account or after a
|
|
DB copy from another environment. Price-level validation (active flag,
|
|
drift) is handled by ``_reconcilePrice``; we don't fail here on archived
|
|
prices, otherwise we'd needlessly re-provision products on every rotation.
|
|
"""
|
|
try:
|
|
if mapping.stripeProductIdUsers:
|
|
stripe.Product.retrieve(mapping.stripeProductIdUsers)
|
|
if mapping.stripeProductIdInstances:
|
|
stripe.Product.retrieve(mapping.stripeProductIdInstances)
|
|
return True
|
|
except Exception as e:
|
|
code = getattr(e, "code", None)
|
|
if code == "resource_missing":
|
|
return False
|
|
logger.debug("Stripe validation check failed (non-critical): %s", e)
|
|
return False
|
|
|
|
|
|
def _processOnePlan(
|
|
stripe,
|
|
planKey: str,
|
|
plan: SubscriptionPlan,
|
|
existingMapping: Optional[StripePlanPrice],
|
|
) -> None:
|
|
"""Reconcile or provision Stripe Products/Prices for a single plan.
|
|
|
|
Each call uses its own DB connection so it is safe to run in a thread pool.
|
|
"""
|
|
stripePeriod = _PERIOD_TO_STRIPE.get(plan.billingPeriod)
|
|
if not stripePeriod:
|
|
return
|
|
|
|
interval = stripePeriod["interval"]
|
|
intervalCount = int(stripePeriod.get("interval_count") or 1)
|
|
db = _getBillingDb()
|
|
|
|
if existingMapping:
|
|
mapping = existingMapping
|
|
hasAllPrices = mapping.stripePriceIdUsers and mapping.stripePriceIdInstances
|
|
hasAllProducts = mapping.stripeProductIdUsers and mapping.stripeProductIdInstances
|
|
if hasAllPrices and hasAllProducts:
|
|
if _validateStripeIdsExist(stripe, mapping):
|
|
changed = False
|
|
reconciledUsers = _reconcilePrice(
|
|
stripe, mapping.stripeProductIdUsers, mapping.stripePriceIdUsers,
|
|
plan.pricePerUserCHF, interval, f"{planKey} — Benutzer-Lizenz",
|
|
intervalCount,
|
|
)
|
|
if reconciledUsers != mapping.stripePriceIdUsers:
|
|
changed = True
|
|
|
|
reconciledInstances = _reconcilePrice(
|
|
stripe, mapping.stripeProductIdInstances, mapping.stripePriceIdInstances,
|
|
plan.pricePerFeatureInstanceCHF, interval, f"{planKey} — Modul",
|
|
intervalCount,
|
|
)
|
|
if reconciledInstances != mapping.stripePriceIdInstances:
|
|
changed = True
|
|
|
|
_archiveOtherRecurringPrices(
|
|
stripe, mapping.stripeProductIdUsers, reconciledUsers, interval, intervalCount,
|
|
)
|
|
_archiveOtherRecurringPrices(
|
|
stripe, mapping.stripeProductIdInstances, reconciledInstances, interval, intervalCount,
|
|
)
|
|
|
|
if changed:
|
|
db.recordModify(StripePlanPrice, mapping.id, {
|
|
"stripePriceIdUsers": reconciledUsers,
|
|
"stripePriceIdInstances": reconciledInstances,
|
|
})
|
|
logger.info(
|
|
"Reconciled Stripe prices for plan %s to catalog (CHF): users=%s, instances=%s",
|
|
planKey, reconciledUsers, reconciledInstances,
|
|
)
|
|
else:
|
|
logger.debug("Stripe prices up-to-date for plan %s", planKey)
|
|
return
|
|
else:
|
|
logger.warning(
|
|
"Stored Stripe IDs for plan %s reference unknown objects "
|
|
"(likely wrong Stripe account or copied DB) — re-provisioning.",
|
|
planKey,
|
|
)
|
|
|
|
productIdUsers = None
|
|
productIdInstances = None
|
|
priceIdUsers = None
|
|
priceIdInstances = None
|
|
|
|
if plan.pricePerUserCHF > 0:
|
|
productIdUsers = _findStripeProduct(stripe, planKey, "users")
|
|
if not productIdUsers:
|
|
productIdUsers = _createStripeProduct(
|
|
stripe, "Benutzer-Lizenzen", f"Benutzer-Lizenzen für {plan.title or planKey}",
|
|
planKey, "users",
|
|
)
|
|
userCents = int(round(plan.pricePerUserCHF * 100))
|
|
priceIdUsers = _findExistingStripePrice(
|
|
stripe, productIdUsers, userCents, interval, intervalCount,
|
|
)
|
|
if not priceIdUsers:
|
|
priceIdUsers = _createStripePrice(
|
|
stripe, productIdUsers, plan.pricePerUserCHF, interval, f"{planKey} — Benutzer-Lizenz",
|
|
intervalCount,
|
|
)
|
|
_archiveOtherRecurringPrices(stripe, productIdUsers, priceIdUsers, interval, intervalCount)
|
|
|
|
if plan.pricePerFeatureInstanceCHF > 0:
|
|
productIdInstances = _findStripeProduct(stripe, planKey, "instances")
|
|
if not productIdInstances:
|
|
productIdInstances = _createStripeProduct(
|
|
stripe, "Module", f"Module für {plan.title or planKey}",
|
|
planKey, "instances",
|
|
)
|
|
instCents = int(round(plan.pricePerFeatureInstanceCHF * 100))
|
|
priceIdInstances = _findExistingStripePrice(
|
|
stripe, productIdInstances, instCents, interval, intervalCount,
|
|
)
|
|
if not priceIdInstances:
|
|
priceIdInstances = _createStripePrice(
|
|
stripe, productIdInstances, plan.pricePerFeatureInstanceCHF, interval,
|
|
f"{planKey} — Modul",
|
|
intervalCount,
|
|
)
|
|
_archiveOtherRecurringPrices(
|
|
stripe, productIdInstances, priceIdInstances, interval, intervalCount,
|
|
)
|
|
|
|
persistData = {
|
|
"stripeProductId": "",
|
|
"stripeProductIdUsers": productIdUsers,
|
|
"stripeProductIdInstances": productIdInstances,
|
|
"stripePriceIdUsers": priceIdUsers,
|
|
"stripePriceIdInstances": priceIdInstances,
|
|
}
|
|
|
|
if existingMapping:
|
|
db.recordModify(StripePlanPrice, existingMapping.id, persistData)
|
|
else:
|
|
db.recordCreate(StripePlanPrice, StripePlanPrice(planKey=planKey, **persistData).model_dump())
|
|
|
|
logger.info(
|
|
"Stripe bootstrapped for %s: users=%s/%s, instances=%s/%s",
|
|
planKey, productIdUsers, priceIdUsers, productIdInstances, priceIdInstances,
|
|
)
|
|
|
|
|
|
def bootstrapStripePrices() -> None:
|
|
"""Ensure all paid plans have separate Stripe Products for users and instances.
|
|
|
|
Plans are processed in parallel (one thread per plan) to reduce boot time.
|
|
Each thread uses its own DB connection; Stripe SDK is thread-safe.
|
|
"""
|
|
try:
|
|
from modules.shared.stripeClient import getStripeClient
|
|
stripe = getStripeClient()
|
|
except ValueError as e:
|
|
logger.error("Stripe not configured — cannot bootstrap subscription prices: %s", e)
|
|
return
|
|
|
|
existing = _loadExistingMappings(_getBillingDb())
|
|
|
|
plans = [
|
|
(planKey, plan)
|
|
for planKey, plan in BUILTIN_PLANS.items()
|
|
if plan.billingPeriod != BillingPeriodEnum.NONE
|
|
and (plan.pricePerUserCHF > 0 or plan.pricePerFeatureInstanceCHF > 0)
|
|
]
|
|
|
|
if not plans:
|
|
return
|
|
|
|
with ThreadPoolExecutor(max_workers=len(plans)) as executor:
|
|
futures = {
|
|
executor.submit(_processOnePlan, stripe, planKey, plan, existing.get(planKey)): planKey
|
|
for planKey, plan in plans
|
|
}
|
|
for future in as_completed(futures):
|
|
planKey = futures[future]
|
|
try:
|
|
future.result()
|
|
except Exception as e:
|
|
logger.error("Stripe bootstrap failed for plan %s: %s", planKey, e)
|
|
|
|
|
|
def getStripePricesForPlan(planKey: str) -> Optional[StripePlanPrice]:
|
|
"""Load the persisted Stripe IDs for a plan."""
|
|
try:
|
|
db = _getBillingDb()
|
|
rows = db.getRecordset(StripePlanPrice, recordFilter={"planKey": planKey})
|
|
if rows:
|
|
return StripePlanPrice(**{k: v for k, v in rows[0].items() if not k.startswith("_")})
|
|
except Exception as e:
|
|
logger.error("Error loading Stripe prices for plan %s: %s", planKey, e)
|
|
return None
|