""" InsightFlow Phase 8 - 订阅与计费系统模块 功能： 1. 多层级订阅计划（Free/Pro/Enterprise） 2. 按量计费（转录时长、存储空间、API 调用次数） 3. 支付集成（Stripe、支付宝、微信支付） 4. 发票管理、退款处理、账单历史 作者: InsightFlow Team """ import json import logging import sqlite3 import uuid from dataclasses import dataclass from datetime import datetime, timedelta from enum import StrEnum from typing import Any logger = logging.getLogger(__name__) class SubscriptionStatus(StrEnum): """订阅状态""" ACTIVE = "active" # 活跃 CANCELLED = "cancelled" # 已取消 EXPIRED = "expired" # 已过期 PAST_DUE = "past_due" # 逾期 TRIAL = "trial" # 试用中 PENDING = "pending" # 待支付 class PaymentProvider(StrEnum): """支付提供商""" STRIPE = "stripe" # Stripe ALIPAY = "alipay" # 支付宝 WECHAT = "wechat" # 微信支付 BANK_TRANSFER = "bank_transfer" # 银行转账 class PaymentStatus(StrEnum): """支付状态""" PENDING = "pending" # 待支付 PROCESSING = "processing" # 处理中 COMPLETED = "completed" # 已完成 FAILED = "failed" # 失败 REFUNDED = "refunded" # 已退款 PARTIAL_REFUNDED = "partial_refunded" # 部分退款 class InvoiceStatus(StrEnum): """发票状态""" DRAFT = "draft" # 草稿 ISSUED = "issued" # 已开具 PAID = "paid" # 已支付 OVERDUE = "overdue" # 逾期 VOID = "void" # 作废 CREDIT_NOTE = "credit_note" # 贷项通知单 class RefundStatus(StrEnum): """退款状态""" PENDING = "pending" # 待处理 APPROVED = "approved" # 已批准 REJECTED = "rejected" # 已拒绝 COMPLETED = "completed" # 已完成 FAILED = "failed" # 失败 @dataclass class SubscriptionPlan: """订阅计划数据类""" id: str name: str tier: str # free/pro/enterprise description: str price_monthly: float # 月付价格 price_yearly: float # 年付价格 currency: str # CNY/USD features: list[str] # 功能列表 limits: dict[str, Any] # 资源限制 is_active: bool created_at: datetime updated_at: datetime metadata: dict[str, Any] @dataclass class Subscription: """订阅数据类""" id: str tenant_id: str plan_id: str status: str current_period_start: datetime current_period_end: datetime cancel_at_period_end: bool canceled_at: datetime | None trial_start: datetime | None trial_end: datetime | None payment_provider: str | None provider_subscription_id: str | None # 支付提供商的订阅ID created_at: datetime updated_at: datetime metadata: dict[str, Any] @dataclass class UsageRecord: """用量记录数据类""" id: str tenant_id: str resource_type: str # transcription/storage/api_call quantity: float # 使用量 unit: str # minutes/mb/count recorded_at: datetime cost: float # 费用 description: str | None metadata: dict[str, Any] @dataclass class Payment: """支付记录数据类""" id: str tenant_id: str subscription_id: str | None invoice_id: str | None amount: float currency: str provider: str provider_payment_id: str | None status: str payment_method: str | None payment_details: dict[str, Any] paid_at: datetime | None failed_at: datetime | None failure_reason: str | None created_at: datetime updated_at: datetime @dataclass class Invoice: """发票数据类""" id: str tenant_id: str subscription_id: str | None invoice_number: str status: str amount_due: float amount_paid: float currency: str period_start: datetime period_end: datetime description: str line_items: list[dict[str, Any]] due_date: datetime paid_at: datetime | None voided_at: datetime | None void_reason: str | None created_at: datetime updated_at: datetime @dataclass class Refund: """退款数据类""" id: str tenant_id: str payment_id: str invoice_id: str | None amount: float currency: str reason: str status: str requested_by: str requested_at: datetime approved_by: str | None approved_at: str | None completed_at: datetime | None provider_refund_id: str | None metadata: dict[str, Any] created_at: datetime updated_at: datetime @dataclass class BillingHistory: """账单历史数据类""" id: str tenant_id: str type: str # subscription/usage/payment/refund amount: float currency: str description: str reference_id: str # 关联的订阅/支付/退款ID balance_after: float # 操作后余额 created_at: datetime metadata: dict[str, Any] class SubscriptionManager: """订阅与计费管理器""" # 默认订阅计划配置 DEFAULT_PLANS = { "free": { "name": "Free", "tier": "free", "description": "免费版，适合个人用户试用", "price_monthly": 0.0, "price_yearly": 0.0, "currency": "CNY", "features": [ "basic_analysis", "export_png", "3_projects", "100_mb_storage", "60_min_transcription", ], "limits": { "max_projects": 3, "max_storage_mb": 100, "max_transcription_minutes": 60, "max_api_calls_per_day": 100, "max_team_members": 2, "max_entities": 100, }, }, "pro": { "name": "Pro", "tier": "pro", "description": "专业版，适合小型团队", "price_monthly": 99.0, "price_yearly": 990.0, "currency": "CNY", "features": [ "all_free_features", "advanced_analysis", "export_all_formats", "api_access", "webhooks", "collaboration", "20_projects", "10_gb_storage", "600_min_transcription", ], "limits": { "max_projects": 20, "max_storage_mb": 10240, "max_transcription_minutes": 600, "max_api_calls_per_day": 10000, "max_team_members": 10, "max_entities": 1000, }, }, "enterprise": { "name": "Enterprise", "tier": "enterprise", "description": "企业版，适合大型企业", "price_monthly": 999.0, "price_yearly": 9990.0, "currency": "CNY", "features": [ "all_pro_features", "unlimited_projects", "unlimited_storage", "unlimited_transcription", "priority_support", "custom_integration", "sla_guarantee", "dedicated_manager", ], "limits": { "max_projects": -1, "max_storage_mb": -1, "max_transcription_minutes": -1, "max_api_calls_per_day": -1, "max_team_members": -1, "max_entities": -1, }, }, } # 按量计费单价（CNY） USAGE_PRICING = { "transcription": { "unit": "minute", "price": 0.5, "free_quota": 60, }, # 0.5元/分钟 # 每月免费额度 "storage": {"unit": "gb", "price": 10.0, "free_quota": 0.1}, # 10元/GB/月 # 100MB免费 "api_call": { "unit": "1000_calls", "price": 5.0, "free_quota": 1000, }, # 5元/1000次 # 每月免费1000次 "export": {"unit": "page", "price": 0.1, "free_quota": 100}, # 0.1元/页（PDF导出） } def __init__(self, db_path: str = "insightflow.db") -> None: self.db_path = db_path self._init_db() self._init_default_plans() def _get_connection(self) -> sqlite3.Connection: """获取数据库连接""" conn = sqlite3.connect(self.db_path) conn.row_factory = sqlite3.Row return conn def _init_db(self) -> None: """初始化数据库表""" conn = self._get_connection() try: cursor = conn.cursor() # 订阅计划表 cursor.execute(""" CREATE TABLE IF NOT EXISTS subscription_plans ( id TEXT PRIMARY KEY, name TEXT NOT NULL, tier TEXT UNIQUE NOT NULL, description TEXT, price_monthly REAL DEFAULT 0, price_yearly REAL DEFAULT 0, currency TEXT DEFAULT 'CNY', features TEXT DEFAULT '[]', limits TEXT DEFAULT '{}', is_active INTEGER DEFAULT 1, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, metadata TEXT DEFAULT '{}' ) """) # 订阅表 cursor.execute(""" CREATE TABLE IF NOT EXISTS subscriptions ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, plan_id TEXT NOT NULL, status TEXT DEFAULT 'pending', current_period_start TIMESTAMP, current_period_end TIMESTAMP, cancel_at_period_end INTEGER DEFAULT 0, canceled_at TIMESTAMP, trial_start TIMESTAMP, trial_end TIMESTAMP, payment_provider TEXT, provider_subscription_id TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, metadata TEXT DEFAULT '{}', FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, FOREIGN KEY (plan_id) REFERENCES subscription_plans(id) ) """) # 用量记录表 cursor.execute(""" CREATE TABLE IF NOT EXISTS usage_records ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, resource_type TEXT NOT NULL, quantity REAL DEFAULT 0, unit TEXT NOT NULL, recorded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, cost REAL DEFAULT 0, description TEXT, metadata TEXT DEFAULT '{}', FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE ) """) # 支付记录表 cursor.execute(""" CREATE TABLE IF NOT EXISTS payments ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, subscription_id TEXT, invoice_id TEXT, amount REAL NOT NULL, currency TEXT DEFAULT 'CNY', provider TEXT NOT NULL, provider_payment_id TEXT, status TEXT DEFAULT 'pending', payment_method TEXT, payment_details TEXT DEFAULT '{}', paid_at TIMESTAMP, failed_at TIMESTAMP, failure_reason TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, FOREIGN KEY (subscription_id) REFERENCES subscriptions(id) ON DELETE SET NULL, FOREIGN KEY (invoice_id) REFERENCES invoices(id) ON DELETE SET NULL ) """) # 发票表 cursor.execute(""" CREATE TABLE IF NOT EXISTS invoices ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, subscription_id TEXT, invoice_number TEXT UNIQUE NOT NULL, status TEXT DEFAULT 'draft', amount_due REAL DEFAULT 0, amount_paid REAL DEFAULT 0, currency TEXT DEFAULT 'CNY', period_start TIMESTAMP, period_end TIMESTAMP, description TEXT, line_items TEXT DEFAULT '[]', due_date TIMESTAMP, paid_at TIMESTAMP, voided_at TIMESTAMP, void_reason TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, FOREIGN KEY (subscription_id) REFERENCES subscriptions(id) ON DELETE SET NULL ) """) # 退款表 cursor.execute(""" CREATE TABLE IF NOT EXISTS refunds ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, payment_id TEXT NOT NULL, invoice_id TEXT, amount REAL NOT NULL, currency TEXT DEFAULT 'CNY', reason TEXT, status TEXT DEFAULT 'pending', requested_by TEXT NOT NULL, requested_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, approved_by TEXT, approved_at TIMESTAMP, completed_at TIMESTAMP, provider_refund_id TEXT, metadata TEXT DEFAULT '{}', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE, FOREIGN KEY (payment_id) REFERENCES payments(id) ON DELETE CASCADE, FOREIGN KEY (invoice_id) REFERENCES invoices(id) ON DELETE SET NULL ) """) # 账单历史表 cursor.execute(""" CREATE TABLE IF NOT EXISTS billing_history ( id TEXT PRIMARY KEY, tenant_id TEXT NOT NULL, type TEXT NOT NULL, amount REAL NOT NULL, currency TEXT DEFAULT 'CNY', description TEXT, reference_id TEXT, balance_after REAL DEFAULT 0, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, metadata TEXT DEFAULT '{}', FOREIGN KEY (tenant_id) REFERENCES tenants(id) ON DELETE CASCADE ) """) # 创建索引 cursor.execute( "CREATE INDEX IF NOT EXISTS idx_subscriptions_tenant ON subscriptions(tenant_id)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_subscriptions_status ON subscriptions(status)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_subscriptions_plan ON subscriptions(plan_id)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_usage_tenant ON usage_records(tenant_id)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_usage_type ON usage_records(resource_type)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_usage_recorded ON usage_records(recorded_at)" ) cursor.execute("CREATE INDEX IF NOT EXISTS idx_payments_tenant ON payments(tenant_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_payments_status ON payments(status)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_invoices_tenant ON invoices(tenant_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_invoices_status ON invoices(status)") cursor.execute( "CREATE INDEX IF NOT EXISTS idx_invoices_number ON invoices(invoice_number)" ) cursor.execute("CREATE INDEX IF NOT EXISTS idx_refunds_tenant ON refunds(tenant_id)") cursor.execute("CREATE INDEX IF NOT EXISTS idx_refunds_status ON refunds(status)") cursor.execute( "CREATE INDEX IF NOT EXISTS idx_billing_tenant ON billing_history(tenant_id)" ) cursor.execute( "CREATE INDEX IF NOT EXISTS idx_billing_created ON billing_history(created_at)" ) conn.commit() logger.info("Subscription tables initialized successfully") except Exception as e: logger.error(f"Error initializing subscription tables: {e}") raise finally: conn.close() def _init_default_plans(self) -> None: """初始化默认订阅计划""" conn = self._get_connection() try: cursor = conn.cursor() for tier, plan_data in self.DEFAULT_PLANS.items(): cursor.execute( """ INSERT OR IGNORE INTO subscription_plans (id, name, tier, description, price_monthly, price_yearly, currency, features, limits, is_active, created_at, updated_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( str(uuid.uuid4()), plan_data["name"], plan_data["tier"], plan_data["description"], plan_data["price_monthly"], plan_data["price_yearly"], plan_data["currency"], json.dumps(plan_data["features"]), json.dumps(plan_data["limits"]), 1, datetime.now(), datetime.now(), json.dumps({}), ), ) conn.commit() logger.info("Default subscription plans initialized") except Exception as e: logger.error(f"Error initializing default plans: {e}") finally: conn.close() # ==================== 订阅计划管理 ==================== def get_plan(self, plan_id: str) -> SubscriptionPlan | None: """获取订阅计划""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM subscription_plans WHERE id = ?", (plan_id, )) row = cursor.fetchone() if row: return self._row_to_plan(row) return None finally: conn.close() def get_plan_by_tier(self, tier: str) -> SubscriptionPlan | None: """通过层级获取订阅计划""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( "SELECT * FROM subscription_plans WHERE tier = ? AND is_active = 1", (tier, ) ) row = cursor.fetchone() if row: return self._row_to_plan(row) return None finally: conn.close() def list_plans(self, include_inactive: bool = False) -> list[SubscriptionPlan]: """列出所有订阅计划""" conn = self._get_connection() try: cursor = conn.cursor() if include_inactive: cursor.execute("SELECT * FROM subscription_plans ORDER BY price_monthly") else: cursor.execute( "SELECT * FROM subscription_plans WHERE is_active = 1 ORDER BY price_monthly" ) rows = cursor.fetchall() return [self._row_to_plan(row) for row in rows] finally: conn.close() def create_plan( self, name: str, tier: str, description: str, price_monthly: float, price_yearly: float, currency: str = "CNY", features: list[str] = None, limits: dict[str, Any] = None, ) -> SubscriptionPlan: """创建新订阅计划""" conn = self._get_connection() try: plan_id = str(uuid.uuid4()) plan = SubscriptionPlan( id=plan_id, name=name, tier=tier, description=description, price_monthly=price_monthly, price_yearly=price_yearly, currency=currency, features=features or [], limits=limits or {}, is_active=True, created_at=datetime.now(), updated_at=datetime.now(), metadata={}, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO subscription_plans (id, name, tier, description, price_monthly, price_yearly, currency, features, limits, is_active, created_at, updated_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( plan.id, plan.name, plan.tier, plan.description, plan.price_monthly, plan.price_yearly, plan.currency, json.dumps(plan.features), json.dumps(plan.limits), int(plan.is_active), plan.created_at, plan.updated_at, json.dumps(plan.metadata), ), ) conn.commit() logger.info(f"Subscription plan created: {plan_id} ({name})") return plan except Exception as e: conn.rollback() logger.error(f"Error creating plan: {e}") raise finally: conn.close() def update_plan(self, plan_id: str, **kwargs) -> SubscriptionPlan | None: """更新订阅计划""" conn = self._get_connection() try: plan = self.get_plan(plan_id) if not plan: return None updates = [] params = [] allowed_fields = [ "name", "description", "price_monthly", "price_yearly", "currency", "features", "limits", "is_active", ] for key, value in kwargs.items(): if key in allowed_fields: updates.append(f"{key} = ?") if key in ["features", "limits"]: params.append(json.dumps(value) if value else "{}") elif key == "is_active": params.append(int(value)) else: params.append(value) if not updates: return plan updates.append("updated_at = ?") params.append(datetime.now()) params.append(plan_id) cursor = conn.cursor() cursor.execute( f""" UPDATE subscription_plans SET {", ".join(updates)} WHERE id = ? """, params, ) conn.commit() return self.get_plan(plan_id) finally: conn.close() # ==================== 订阅管理 ==================== def create_subscription( self, tenant_id: str, plan_id: str, payment_provider: str | None = None, trial_days: int = 0, billing_cycle: str = "monthly", ) -> Subscription: """创建新订阅""" conn = self._get_connection() try: # 检查是否已有活跃订阅 cursor = conn.cursor() cursor.execute( """ SELECT * FROM subscriptions WHERE tenant_id = ? AND status IN ('active', 'trial', 'pending') """, (tenant_id, ), ) existing = cursor.fetchone() if existing: raise ValueError(f"Tenant {tenant_id} already has an active subscription") # 获取计划信息 plan = self.get_plan(plan_id) if not plan: raise ValueError(f"Plan {plan_id} not found") subscription_id = str(uuid.uuid4()) now = datetime.now() # 计算周期 if billing_cycle == "yearly": period_end = now + timedelta(days=365) else: period_end = now + timedelta(days=30) # 试用处理 trial_start = None trial_end = None if trial_days > 0: trial_start = now trial_end = now + timedelta(days=trial_days) status = SubscriptionStatus.TRIAL.value else: status = SubscriptionStatus.PENDING.value subscription = Subscription( id=subscription_id, tenant_id=tenant_id, plan_id=plan_id, status=status, current_period_start=now, current_period_end=period_end, cancel_at_period_end=False, canceled_at=None, trial_start=trial_start, trial_end=trial_end, payment_provider=payment_provider, provider_subscription_id=None, created_at=now, updated_at=now, metadata={"billing_cycle": billing_cycle}, ) cursor.execute( """ INSERT INTO subscriptions (id, tenant_id, plan_id, status, current_period_start, current_period_end, cancel_at_period_end, canceled_at, trial_start, trial_end, payment_provider, provider_subscription_id, created_at, updated_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( subscription.id, subscription.tenant_id, subscription.plan_id, subscription.status, subscription.current_period_start, subscription.current_period_end, int(subscription.cancel_at_period_end), subscription.canceled_at, subscription.trial_start, subscription.trial_end, subscription.payment_provider, subscription.provider_subscription_id, subscription.created_at, subscription.updated_at, json.dumps(subscription.metadata), ), ) # 创建发票 amount = plan.price_yearly if billing_cycle == "yearly" else plan.price_monthly if amount > 0 and trial_days == 0: self._create_invoice_internal( conn, tenant_id, subscription_id, amount, plan.currency, now, period_end, f"{plan.name} Subscription ({billing_cycle})", ) # 记录账单历史 self._add_billing_history_internal( conn, tenant_id, "subscription", 0, plan.currency, f"Subscription created: {plan.name}", subscription_id, 0, ) conn.commit() logger.info(f"Subscription created: {subscription_id} for tenant {tenant_id}") return subscription except Exception as e: conn.rollback() logger.error(f"Error creating subscription: {e}") raise finally: conn.close() def get_subscription(self, subscription_id: str) -> Subscription | None: """获取订阅信息""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM subscriptions WHERE id = ?", (subscription_id, )) row = cursor.fetchone() if row: return self._row_to_subscription(row) return None finally: conn.close() def get_tenant_subscription(self, tenant_id: str) -> Subscription | None: """获取租户的当前订阅""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT * FROM subscriptions WHERE tenant_id = ? AND status IN ('active', 'trial', 'past_due', 'pending') ORDER BY created_at DESC LIMIT 1 """, (tenant_id, ), ) row = cursor.fetchone() if row: return self._row_to_subscription(row) return None finally: conn.close() def update_subscription(self, subscription_id: str, **kwargs) -> Subscription | None: """更新订阅""" conn = self._get_connection() try: subscription = self.get_subscription(subscription_id) if not subscription: return None updates = [] params = [] allowed_fields = [ "status", "current_period_start", "current_period_end", "cancel_at_period_end", "canceled_at", "trial_end", "payment_provider", "provider_subscription_id", ] for key, value in kwargs.items(): if key in allowed_fields: updates.append(f"{key} = ?") if key == "cancel_at_period_end": params.append(int(value)) else: params.append(value) if not updates: return subscription updates.append("updated_at = ?") params.append(datetime.now()) params.append(subscription_id) cursor = conn.cursor() cursor.execute( f""" UPDATE subscriptions SET {", ".join(updates)} WHERE id = ? """, params, ) conn.commit() return self.get_subscription(subscription_id) finally: conn.close() def cancel_subscription( self, subscription_id: str, at_period_end: bool = True ) -> Subscription | None: """取消订阅""" conn = self._get_connection() try: subscription = self.get_subscription(subscription_id) if not subscription: return None now = datetime.now() if at_period_end: # 在周期结束时取消 cursor = conn.cursor() cursor.execute( """ UPDATE subscriptions SET cancel_at_period_end = 1, canceled_at = ?, updated_at = ? WHERE id = ? """, (now, now, subscription_id), ) else: # 立即取消 cursor = conn.cursor() cursor.execute( """ UPDATE subscriptions SET status = 'cancelled', canceled_at = ?, updated_at = ? WHERE id = ? """, (now, now, subscription_id), ) # 记录账单历史 self._add_billing_history_internal( conn, subscription.tenant_id, "subscription", 0, "CNY", f"Subscription cancelled{' (at period end)' if at_period_end else ''}", subscription_id, 0, ) conn.commit() logger.info(f"Subscription cancelled: {subscription_id}") return self.get_subscription(subscription_id) finally: conn.close() def change_plan( self, subscription_id: str, new_plan_id: str, prorate: bool = True ) -> Subscription | None: """更改订阅计划""" conn = self._get_connection() try: subscription = self.get_subscription(subscription_id) if not subscription: return None old_plan = self.get_plan(subscription.plan_id) new_plan = self.get_plan(new_plan_id) if not new_plan: raise ValueError(f"Plan {new_plan_id} not found") now = datetime.now() # 按比例计算差价（简化实现） if prorate and old_plan: # 这里应该实现实际的按比例计算逻辑 pass cursor = conn.cursor() cursor.execute( """ UPDATE subscriptions SET plan_id = ?, updated_at = ? WHERE id = ? """, (new_plan_id, now, subscription_id), ) # 记录账单历史 self._add_billing_history_internal( conn, subscription.tenant_id, "subscription", 0, new_plan.currency, f"Plan changed from {old_plan.name if old_plan else 'unknown'} to {new_plan.name}", subscription_id, 0, ) conn.commit() logger.info(f"Subscription plan changed: {subscription_id} -> {new_plan_id}") return self.get_subscription(subscription_id) finally: conn.close() # ==================== 用量计费 ==================== def record_usage( self, tenant_id: str, resource_type: str, quantity: float, unit: str, description: str | None = None, metadata: dict | None = None, ) -> UsageRecord: """记录用量""" conn = self._get_connection() try: # 计算费用 cost = self._calculate_usage_cost(resource_type, quantity) record_id = str(uuid.uuid4()) record = UsageRecord( id=record_id, tenant_id=tenant_id, resource_type=resource_type, quantity=quantity, unit=unit, recorded_at=datetime.now(), cost=cost, description=description, metadata=metadata or {}, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO usage_records (id, tenant_id, resource_type, quantity, unit, recorded_at, cost, description, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( record.id, record.tenant_id, record.resource_type, record.quantity, record.unit, record.recorded_at, record.cost, record.description, json.dumps(record.metadata), ), ) conn.commit() return record finally: conn.close() def get_usage_summary( self, tenant_id: str, start_date: datetime | None = None, end_date: datetime | None = None ) -> dict[str, Any]: """获取用量汇总""" conn = self._get_connection() try: cursor = conn.cursor() query = """ SELECT resource_type, SUM(quantity) as total_quantity, SUM(cost) as total_cost, COUNT(*) as record_count FROM usage_records WHERE tenant_id = ? """ params = [tenant_id] if start_date: query += " AND recorded_at >= ?" params.append(start_date) if end_date: query += " AND recorded_at <= ?" params.append(end_date) query += " GROUP BY resource_type" cursor.execute(query, params) rows = cursor.fetchall() summary = {} total_cost = 0 for row in rows: summary[row["resource_type"]] = { "quantity": row["total_quantity"], "cost": row["total_cost"], "records": row["record_count"], } total_cost += row["total_cost"] return { "tenant_id": tenant_id, "period": { "start": start_date.isoformat() if start_date else None, "end": end_date.isoformat() if end_date else None, }, "breakdown": summary, "total_cost": total_cost, } finally: conn.close() def _calculate_usage_cost(self, resource_type: str, quantity: float) -> float: """计算用量费用""" pricing = self.USAGE_PRICING.get(resource_type) if not pricing: return 0.0 # 扣除免费额度 chargeable = max(0, quantity - pricing.get("free_quota", 0)) # 计算费用 if pricing["unit"] == "1000_calls": return (chargeable / 1000) * pricing["price"] else: return chargeable * pricing["price"] # ==================== 支付管理 ==================== def create_payment( self, tenant_id: str, amount: float, currency: str, provider: str, subscription_id: str | None = None, invoice_id: str | None = None, payment_method: str | None = None, payment_details: dict | None = None, ) -> Payment: """创建支付记录""" conn = self._get_connection() try: payment_id = str(uuid.uuid4()) now = datetime.now() payment = Payment( id=payment_id, tenant_id=tenant_id, subscription_id=subscription_id, invoice_id=invoice_id, amount=amount, currency=currency, provider=provider, provider_payment_id=None, status=PaymentStatus.PENDING.value, payment_method=payment_method, payment_details=payment_details or {}, paid_at=None, failed_at=None, failure_reason=None, created_at=now, updated_at=now, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO payments (id, tenant_id, subscription_id, invoice_id, amount, currency, provider, provider_payment_id, status, payment_method, payment_details, paid_at, failed_at, failure_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( payment.id, payment.tenant_id, payment.subscription_id, payment.invoice_id, payment.amount, payment.currency, payment.provider, payment.provider_payment_id, payment.status, payment.payment_method, json.dumps(payment.payment_details), payment.paid_at, payment.failed_at, payment.failure_reason, payment.created_at, payment.updated_at, ), ) conn.commit() return payment finally: conn.close() def confirm_payment( self, payment_id: str, provider_payment_id: str | None = None ) -> Payment | None: """确认支付完成""" conn = self._get_connection() try: payment = self._get_payment_internal(conn, payment_id) if not payment: return None now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE payments SET status = 'completed', provider_payment_id = ?, paid_at = ?, updated_at = ? WHERE id = ? """, (provider_payment_id, now, now, payment_id), ) # 如果有关联发票，更新发票状态 if payment.invoice_id: cursor.execute( """ UPDATE invoices SET status = 'paid', amount_paid = amount_due, paid_at = ? WHERE id = ? """, (now, payment.invoice_id), ) # 如果有关联订阅，激活订阅 if payment.subscription_id: cursor.execute( """ UPDATE subscriptions SET status = 'active', updated_at = ? WHERE id = ? AND status = 'pending' """, (now, payment.subscription_id), ) # 记录账单历史 self._add_billing_history_internal( conn, payment.tenant_id, "payment", payment.amount, payment.currency, f"Payment completed via {payment.provider}", payment_id, 0, # 余额更新应该在账户管理中处理 ) conn.commit() logger.info(f"Payment confirmed: {payment_id}") return self._get_payment_internal(conn, payment_id) finally: conn.close() def fail_payment(self, payment_id: str, reason: str) -> Payment | None: """标记支付失败""" conn = self._get_connection() try: now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE payments SET status = 'failed', failure_reason = ?, failed_at = ?, updated_at = ? WHERE id = ? """, (reason, now, now, payment_id), ) conn.commit() return self._get_payment_internal(conn, payment_id) finally: conn.close() def get_payment(self, payment_id: str) -> Payment | None: """获取支付记录""" conn = self._get_connection() try: return self._get_payment_internal(conn, payment_id) finally: conn.close() def list_payments( self, tenant_id: str, status: str | None = None, limit: int = 100, offset: int = 0 ) -> list[Payment]: """列出支付记录""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM payments WHERE tenant_id = ?" params = [tenant_id] if status: query += " AND status = ?" params.append(status) query += " ORDER BY created_at DESC LIMIT ? OFFSET ?" params.extend([limit, offset]) cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_payment(row) for row in rows] finally: conn.close() def _get_payment_internal(self, conn: sqlite3.Connection, payment_id: str) -> Payment | None: """内部方法：获取支付记录""" cursor = conn.cursor() cursor.execute("SELECT * FROM payments WHERE id = ?", (payment_id, )) row = cursor.fetchone() if row: return self._row_to_payment(row) return None # ==================== 发票管理 ==================== def _create_invoice_internal( self, conn: sqlite3.Connection, tenant_id: str, subscription_id: str | None, amount: float, currency: str, period_start: datetime, period_end: datetime, description: str, line_items: list[dict] | None = None, ) -> Invoice: """内部方法：创建发票""" invoice_id = str(uuid.uuid4()) invoice_number = self._generate_invoice_number() now = datetime.now() due_date = now + timedelta(days=7) # 7天付款期限 invoice = Invoice( id=invoice_id, tenant_id=tenant_id, subscription_id=subscription_id, invoice_number=invoice_number, status=InvoiceStatus.DRAFT.value, amount_due=amount, amount_paid=0, currency=currency, period_start=period_start, period_end=period_end, description=description, line_items=line_items or [{"description": description, "amount": amount}], due_date=due_date, paid_at=None, voided_at=None, void_reason=None, created_at=now, updated_at=now, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO invoices (id, tenant_id, subscription_id, invoice_number, status, amount_due, amount_paid, currency, period_start, period_end, description, line_items, due_date, paid_at, voided_at, void_reason, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( invoice.id, invoice.tenant_id, invoice.subscription_id, invoice.invoice_number, invoice.status, invoice.amount_due, invoice.amount_paid, invoice.currency, invoice.period_start, invoice.period_end, invoice.description, json.dumps(invoice.line_items), invoice.due_date, invoice.paid_at, invoice.voided_at, invoice.void_reason, invoice.created_at, invoice.updated_at, ), ) return invoice def get_invoice(self, invoice_id: str) -> Invoice | None: """获取发票""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM invoices WHERE id = ?", (invoice_id, )) row = cursor.fetchone() if row: return self._row_to_invoice(row) return None finally: conn.close() def get_invoice_by_number(self, invoice_number: str) -> Invoice | None: """通过发票号获取发票""" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute("SELECT * FROM invoices WHERE invoice_number = ?", (invoice_number, )) row = cursor.fetchone() if row: return self._row_to_invoice(row) return None finally: conn.close() def list_invoices( self, tenant_id: str, status: str | None = None, limit: int = 100, offset: int = 0 ) -> list[Invoice]: """列出发票""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM invoices WHERE tenant_id = ?" params = [tenant_id] if status: query += " AND status = ?" params.append(status) query += " ORDER BY created_at DESC LIMIT ? OFFSET ?" params.extend([limit, offset]) cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_invoice(row) for row in rows] finally: conn.close() def void_invoice(self, invoice_id: str, reason: str) -> Invoice | None: """作废发票""" conn = self._get_connection() try: invoice = self.get_invoice(invoice_id) if not invoice: return None if invoice.status == InvoiceStatus.PAID.value: raise ValueError("Cannot void a paid invoice") now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE invoices SET status = 'void', voided_at = ?, void_reason = ?, updated_at = ? WHERE id = ? """, (now, reason, now, invoice_id), ) conn.commit() return self.get_invoice(invoice_id) finally: conn.close() def _generate_invoice_number(self) -> str: """生成发票号""" now = datetime.now() prefix = f"INV-{now.strftime('%Y%m')}" conn = self._get_connection() try: cursor = conn.cursor() cursor.execute( """ SELECT COUNT(*) as count FROM invoices WHERE invoice_number LIKE ? """, (f"{prefix}%", ), ) row = cursor.fetchone() count = row["count"] + 1 return f"{prefix}-{count:06d}" finally: conn.close() # ==================== 退款管理 ==================== def request_refund( self, tenant_id: str, payment_id: str, amount: float, reason: str, requested_by: str ) -> Refund: """申请退款""" conn = self._get_connection() try: # 验证支付记录 payment = self._get_payment_internal(conn, payment_id) if not payment: raise ValueError(f"Payment {payment_id} not found") if payment.tenant_id != tenant_id: raise ValueError("Payment does not belong to this tenant") if payment.status != PaymentStatus.COMPLETED.value: raise ValueError("Can only refund completed payments") if amount > payment.amount: raise ValueError("Refund amount cannot exceed payment amount") refund_id = str(uuid.uuid4()) now = datetime.now() refund = Refund( id=refund_id, tenant_id=tenant_id, payment_id=payment_id, invoice_id=payment.invoice_id, amount=amount, currency=payment.currency, reason=reason, status=RefundStatus.PENDING.value, requested_by=requested_by, requested_at=now, approved_by=None, approved_at=None, completed_at=None, provider_refund_id=None, metadata={}, created_at=now, updated_at=now, ) cursor = conn.cursor() cursor.execute( """ INSERT INTO refunds (id, tenant_id, payment_id, invoice_id, amount, currency, reason, status, requested_by, requested_at, approved_by, approved_at, completed_at, provider_refund_id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( refund.id, refund.tenant_id, refund.payment_id, refund.invoice_id, refund.amount, refund.currency, refund.reason, refund.status, refund.requested_by, refund.requested_at, refund.approved_by, refund.approved_at, refund.completed_at, refund.provider_refund_id, json.dumps(refund.metadata), refund.created_at, refund.updated_at, ), ) conn.commit() logger.info(f"Refund requested: {refund_id} for payment {payment_id}") return refund finally: conn.close() def approve_refund(self, refund_id: str, approved_by: str) -> Refund | None: """批准退款""" conn = self._get_connection() try: refund = self._get_refund_internal(conn, refund_id) if not refund: return None if refund.status != RefundStatus.PENDING.value: raise ValueError("Can only approve pending refunds") now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE refunds SET status = 'approved', approved_by = ?, approved_at = ?, updated_at = ? WHERE id = ? """, (approved_by, now, now, refund_id), ) conn.commit() return self._get_refund_internal(conn, refund_id) finally: conn.close() def complete_refund( self, refund_id: str, provider_refund_id: str | None = None ) -> Refund | None: """完成退款""" conn = self._get_connection() try: refund = self._get_refund_internal(conn, refund_id) if not refund: return None now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE refunds SET status = 'completed', provider_refund_id = ?, completed_at = ?, updated_at = ? WHERE id = ? """, (provider_refund_id, now, now, refund_id), ) # 更新原支付记录状态 cursor.execute( """ UPDATE payments SET status = 'refunded', updated_at = ? WHERE id = ? """, (now, refund.payment_id), ) # 记录账单历史 self._add_billing_history_internal( conn, refund.tenant_id, "refund", -refund.amount, refund.currency, f"Refund processed: {refund.reason}", refund_id, 0, ) conn.commit() logger.info(f"Refund completed: {refund_id}") return self._get_refund_internal(conn, refund_id) finally: conn.close() def reject_refund(self, refund_id: str, reason: str) -> Refund | None: """拒绝退款""" conn = self._get_connection() try: refund = self._get_refund_internal(conn, refund_id) if not refund: return None now = datetime.now() cursor = conn.cursor() cursor.execute( """ UPDATE refunds SET status = 'rejected', metadata = json_set(metadata, '$.rejection_reason', ?), updated_at = ? WHERE id = ? """, (reason, now, refund_id), ) conn.commit() return self._get_refund_internal(conn, refund_id) finally: conn.close() def get_refund(self, refund_id: str) -> Refund | None: """获取退款记录""" conn = self._get_connection() try: return self._get_refund_internal(conn, refund_id) finally: conn.close() def list_refunds( self, tenant_id: str, status: str | None = None, limit: int = 100, offset: int = 0 ) -> list[Refund]: """列出退款记录""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM refunds WHERE tenant_id = ?" params = [tenant_id] if status: query += " AND status = ?" params.append(status) query += " ORDER BY created_at DESC LIMIT ? OFFSET ?" params.extend([limit, offset]) cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_refund(row) for row in rows] finally: conn.close() def _get_refund_internal(self, conn: sqlite3.Connection, refund_id: str) -> Refund | None: """内部方法：获取退款记录""" cursor = conn.cursor() cursor.execute("SELECT * FROM refunds WHERE id = ?", (refund_id, )) row = cursor.fetchone() if row: return self._row_to_refund(row) return None # ==================== 账单历史 ==================== def _add_billing_history_internal( self, conn: sqlite3.Connection, tenant_id: str, type: str, amount: float, currency: str, description: str, reference_id: str, balance_after: float, ) -> None: """内部方法：添加账单历史""" history_id = str(uuid.uuid4()) cursor = conn.cursor() cursor.execute( """ INSERT INTO billing_history (id, tenant_id, type, amount, currency, description, reference_id, balance_after, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( history_id, tenant_id, type, amount, currency, description, reference_id, balance_after, datetime.now(), json.dumps({}), ), ) def get_billing_history( self, tenant_id: str, start_date: datetime | None = None, end_date: datetime | None = None, limit: int = 100, offset: int = 0, ) -> list[BillingHistory]: """获取账单历史""" conn = self._get_connection() try: cursor = conn.cursor() query = "SELECT * FROM billing_history WHERE tenant_id = ?" params = [tenant_id] if start_date: query += " AND created_at >= ?" params.append(start_date) if end_date: query += " AND created_at <= ?" params.append(end_date) query += " ORDER BY created_at DESC LIMIT ? OFFSET ?" params.extend([limit, offset]) cursor.execute(query, params) rows = cursor.fetchall() return [self._row_to_billing_history(row) for row in rows] finally: conn.close() # ==================== 支付提供商集成 ==================== def create_stripe_checkout_session( self, tenant_id: str, plan_id: str, success_url: str, cancel_url: str, billing_cycle: str = "monthly", ) -> dict[str, Any]: """创建 Stripe Checkout 会话（占位实现）""" # 这里应该集成 Stripe SDK # 简化实现，返回模拟数据 return { "session_id": f"cs_{uuid.uuid4().hex[:24]}", "url": f"https://checkout.stripe.com/mock/{uuid.uuid4().hex[:24]}", "status": "created", "provider": "stripe", } def create_alipay_order( self, tenant_id: str, plan_id: str, billing_cycle: str = "monthly" ) -> dict[str, Any]: """创建支付宝订单（占位实现）""" # 这里应该集成支付宝 SDK plan = self.get_plan(plan_id) amount = plan.price_yearly if billing_cycle == "yearly" else plan.price_monthly return { "order_id": f"ALI{datetime.now().strftime('%Y%m%d%H%M%S')}{uuid.uuid4().hex[:8].upper()}", "amount": amount, "currency": plan.currency, "qr_code_url": f"https://qr.alipay.com/mock/{uuid.uuid4().hex[:16]}", "status": "pending", "provider": "alipay", } def create_wechat_order( self, tenant_id: str, plan_id: str, billing_cycle: str = "monthly" ) -> dict[str, Any]: """创建微信支付订单（占位实现）""" # 这里应该集成微信支付 SDK plan = self.get_plan(plan_id) amount = plan.price_yearly if billing_cycle == "yearly" else plan.price_monthly return { "order_id": f"WX{datetime.now().strftime('%Y%m%d%H%M%S')}{uuid.uuid4().hex[:8].upper()}", "amount": amount, "currency": plan.currency, "prepay_id": f"wx{uuid.uuid4().hex[:32]}", "status": "pending", "provider": "wechat", } def handle_webhook(self, provider: str, payload: dict[str, Any]) -> bool: """处理支付提供商的 Webhook（占位实现）""" # 这里应该实现实际的 Webhook 处理逻辑 logger.info(f"Received webhook from {provider}: {payload.get('event_type', 'unknown')}") event_type = payload.get("event_type", "") if provider == "stripe": if event_type == "checkout.session.completed": # 处理支付完成 pass elif event_type == "invoice.payment_failed": # 处理支付失败 pass elif provider in ["alipay", "wechat"]: if payload.get("trade_status") == "TRADE_SUCCESS": # 处理支付完成 pass return True # ==================== 辅助方法 ==================== def _row_to_plan(self, row: sqlite3.Row) -> SubscriptionPlan: """数据库行转换为 SubscriptionPlan 对象""" return SubscriptionPlan( id=row["id"], name=row["name"], tier=row["tier"], description=row["description"] or "", price_monthly=row["price_monthly"], price_yearly=row["price_yearly"], currency=row["currency"], features=json.loads(row["features"] or "[]"), limits=json.loads(row["limits"] or "{}"), is_active=bool(row["is_active"]), created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), metadata=json.loads(row["metadata"] or "{}"), ) def _row_to_subscription(self, row: sqlite3.Row) -> Subscription: """数据库行转换为 Subscription 对象""" return Subscription( id=row["id"], tenant_id=row["tenant_id"], plan_id=row["plan_id"], status=row["status"], current_period_start=( datetime.fromisoformat(row["current_period_start"]) if row["current_period_start"] and isinstance(row["current_period_start"], str) else row["current_period_start"] ), current_period_end=( datetime.fromisoformat(row["current_period_end"]) if row["current_period_end"] and isinstance(row["current_period_end"], str) else row["current_period_end"] ), cancel_at_period_end=bool(row["cancel_at_period_end"]), canceled_at=( datetime.fromisoformat(row["canceled_at"]) if row["canceled_at"] and isinstance(row["canceled_at"], str) else row["canceled_at"] ), trial_start=( datetime.fromisoformat(row["trial_start"]) if row["trial_start"] and isinstance(row["trial_start"], str) else row["trial_start"] ), trial_end=( datetime.fromisoformat(row["trial_end"]) if row["trial_end"] and isinstance(row["trial_end"], str) else row["trial_end"] ), payment_provider=row["payment_provider"], provider_subscription_id=row["provider_subscription_id"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), metadata=json.loads(row["metadata"] or "{}"), ) def _row_to_usage(self, row: sqlite3.Row) -> UsageRecord: """数据库行转换为 UsageRecord 对象""" return UsageRecord( id=row["id"], tenant_id=row["tenant_id"], resource_type=row["resource_type"], quantity=row["quantity"], unit=row["unit"], recorded_at=( datetime.fromisoformat(row["recorded_at"]) if isinstance(row["recorded_at"], str) else row["recorded_at"] ), cost=row["cost"], description=row["description"], metadata=json.loads(row["metadata"] or "{}"), ) def _row_to_payment(self, row: sqlite3.Row) -> Payment: """数据库行转换为 Payment 对象""" return Payment( id=row["id"], tenant_id=row["tenant_id"], subscription_id=row["subscription_id"], invoice_id=row["invoice_id"], amount=row["amount"], currency=row["currency"], provider=row["provider"], provider_payment_id=row["provider_payment_id"], status=row["status"], payment_method=row["payment_method"], payment_details=json.loads(row["payment_details"] or "{}"), paid_at=( datetime.fromisoformat(row["paid_at"]) if row["paid_at"] and isinstance(row["paid_at"], str) else row["paid_at"] ), failed_at=( datetime.fromisoformat(row["failed_at"]) if row["failed_at"] and isinstance(row["failed_at"], str) else row["failed_at"] ), failure_reason=row["failure_reason"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), ) def _row_to_invoice(self, row: sqlite3.Row) -> Invoice: """数据库行转换为 Invoice 对象""" return Invoice( id=row["id"], tenant_id=row["tenant_id"], subscription_id=row["subscription_id"], invoice_number=row["invoice_number"], status=row["status"], amount_due=row["amount_due"], amount_paid=row["amount_paid"], currency=row["currency"], period_start=( datetime.fromisoformat(row["period_start"]) if row["period_start"] and isinstance(row["period_start"], str) else row["period_start"] ), period_end=( datetime.fromisoformat(row["period_end"]) if row["period_end"] and isinstance(row["period_end"], str) else row["period_end"] ), description=row["description"], line_items=json.loads(row["line_items"] or "[]"), due_date=( datetime.fromisoformat(row["due_date"]) if row["due_date"] and isinstance(row["due_date"], str) else row["due_date"] ), paid_at=( datetime.fromisoformat(row["paid_at"]) if row["paid_at"] and isinstance(row["paid_at"], str) else row["paid_at"] ), voided_at=( datetime.fromisoformat(row["voided_at"]) if row["voided_at"] and isinstance(row["voided_at"], str) else row["voided_at"] ), void_reason=row["void_reason"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), ) def _row_to_refund(self, row: sqlite3.Row) -> Refund: """数据库行转换为 Refund 对象""" return Refund( id=row["id"], tenant_id=row["tenant_id"], payment_id=row["payment_id"], invoice_id=row["invoice_id"], amount=row["amount"], currency=row["currency"], reason=row["reason"], status=row["status"], requested_by=row["requested_by"], requested_at=( datetime.fromisoformat(row["requested_at"]) if isinstance(row["requested_at"], str) else row["requested_at"] ), approved_by=row["approved_by"], approved_at=( datetime.fromisoformat(row["approved_at"]) if row["approved_at"] and isinstance(row["approved_at"], str) else row["approved_at"] ), completed_at=( datetime.fromisoformat(row["completed_at"]) if row["completed_at"] and isinstance(row["completed_at"], str) else row["completed_at"] ), provider_refund_id=row["provider_refund_id"], metadata=json.loads(row["metadata"] or "{}"), created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), updated_at=( datetime.fromisoformat(row["updated_at"]) if isinstance(row["updated_at"], str) else row["updated_at"] ), ) def _row_to_billing_history(self, row: sqlite3.Row) -> BillingHistory: """数据库行转换为 BillingHistory 对象""" return BillingHistory( id=row["id"], tenant_id=row["tenant_id"], type=row["type"], amount=row["amount"], currency=row["currency"], description=row["description"], reference_id=row["reference_id"], balance_after=row["balance_after"], created_at=( datetime.fromisoformat(row["created_at"]) if isinstance(row["created_at"], str) else row["created_at"] ), metadata=json.loads(row["metadata"] or "{}"), ) # 全局订阅管理器实例 subscription_manager = None def get_subscription_manager(db_path: str = "insightflow.db") -> SubscriptionManager: """获取订阅管理器实例（单例模式）""" global subscription_manager if subscription_manager is None: subscription_manager = SubscriptionManager(db_path) return subscription_manager