Download core/utils/scripts/fix_missed_webhooks.py from Kyrlos11/thio: direct link, hf CLI and curl.
- Browser
- Download file 19.5 kB
-
https://huggingface.co/spaces/Kyrlos11/thio/resolve/main/core/utils/scripts/fix_missed_webhooks.py
- Command line
-
hf download hf://spaces/Kyrlos11/thio/core/utils/scripts/fix_missed_webhooks.py
-
curl -L -o fix_missed_webhooks.py https://huggingface.co/spaces/Kyrlos11/thio/resolve/main/core/utils/scripts/fix_missed_webhooks.py
19.5 kB
| #!/usr/bin/env python3 | |
| """ | |
| Script to fix users affected by missed webhooks due to endpoint change. | |
| Handles three types of affected users: | |
| 1. New signups who didn't get tier set up (stuck on 'none' tier) | |
| 2. Users who had renewals and didn't receive credits | |
| 3. Users who upgraded and didn't get tier updated | |
| Usage: | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --dry-run | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --only signups | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --only renewals | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --only upgrades | |
| """ | |
| import asyncio | |
| import sys | |
| import argparse | |
| from pathlib import Path | |
| from datetime import datetime, timezone, timedelta | |
| from decimal import Decimal | |
| from typing import List, Dict | |
| backend_dir = Path(__file__).parent.parent.parent.parent | |
| sys.path.insert(0, str(backend_dir)) | |
| import stripe | |
| from core.services.supabase import DBConnection | |
| from core.utils.config import config | |
| from core.utils.logger import logger | |
| from core.billing.shared.config import get_tier_by_price_id, get_plan_type | |
| from core.billing.credits.manager import credit_manager | |
| from dateutil.relativedelta import relativedelta | |
| stripe.api_key = config.STRIPE_SECRET_KEY | |
| async def fix_new_signups(target_date: str, dry_run: bool = False): | |
| """Fix users stuck on 'none' tier who have active Stripe subscriptions.""" | |
| logger.info("="*80) | |
| logger.info(f"FIXING USERS STUCK ON 'NONE' TIER") | |
| logger.info("="*80) | |
| db = DBConnection() | |
| await db.initialize() | |
| client = await db.client | |
| logger.info("Searching database for users stuck on 'none' tier with active Stripe subscriptions...") | |
| batch_size = 1000 | |
| offset = 0 | |
| fixed_count = 0 | |
| skipped_count = 0 | |
| total_checked = 0 | |
| while True: | |
| # Get users with tier='none' who have a stripe_subscription_id | |
| affected_users = await client.from_('credit_accounts').select( | |
| 'account_id, tier, stripe_subscription_id, stripe_subscription_status, balance' | |
| ).eq('tier', 'none').not_.is_('stripe_subscription_id', 'null').range( | |
| offset, offset + batch_size - 1 | |
| ).execute() | |
| if not affected_users.data: | |
| break | |
| logger.info(f"\nBatch {offset//batch_size + 1}: Processing {len(affected_users.data)} users...") | |
| for user_data in affected_users.data: | |
| total_checked += 1 | |
| try: | |
| account_id = user_data['account_id'] | |
| current_sub_id = user_data.get('stripe_subscription_id') | |
| # Fetch subscription from Stripe | |
| try: | |
| subscription = await stripe.Subscription.retrieve_async( | |
| current_sub_id, | |
| expand=['items.data.price'] | |
| ) | |
| except Exception as e: | |
| logger.warning(f"⚠️ Could not fetch subscription {current_sub_id} for {account_id}: {e}") | |
| skipped_count += 1 | |
| continue | |
| if subscription.status not in ['active', 'trialing', 'past_due']: | |
| skipped_count += 1 | |
| continue | |
| # Get price info | |
| items = subscription.get('items') | |
| if not items or not items.get('data'): | |
| logger.warning(f"⚠️ Subscription {current_sub_id} has no items") | |
| skipped_count += 1 | |
| continue | |
| price_id = items['data'][0]['price']['id'] | |
| tier_info = get_tier_by_price_id(price_id) | |
| if not tier_info: | |
| logger.warning(f"⚠️ Unknown price_id {price_id} for subscription {current_sub_id}") | |
| skipped_count += 1 | |
| continue | |
| logger.info(f"{'[DRY RUN] ' if dry_run else ''}Fixing {account_id}: tier=none -> {tier_info.name}") | |
| if not dry_run: | |
| # Set up subscription | |
| billing_anchor = datetime.fromtimestamp(subscription.current_period_start, tz=timezone.utc) | |
| next_grant_date = datetime.fromtimestamp(subscription.current_period_end, tz=timezone.utc) | |
| plan_type = get_plan_type(price_id) | |
| if plan_type == 'yearly': | |
| next_grant_date = billing_anchor + relativedelta(months=1) | |
| # Update tier | |
| await client.from_('credit_accounts').update({ | |
| 'tier': tier_info.name, | |
| 'plan_type': plan_type, | |
| 'stripe_subscription_status': subscription.status, | |
| 'billing_cycle_anchor': billing_anchor.isoformat(), | |
| 'next_credit_grant': next_grant_date.isoformat(), | |
| 'last_grant_date': billing_anchor.isoformat() | |
| }).eq('account_id', account_id).execute() | |
| # Grant initial credits if needed | |
| current_balance = Decimal(str(user_data.get('balance', 0))) | |
| if tier_info.monthly_refill_enabled and current_balance < Decimal('1.0'): | |
| await credit_manager.add_credits( | |
| account_id=account_id, | |
| amount=tier_info.monthly_credits, | |
| is_expiring=True, | |
| description=f"Initial credits for {tier_info.display_name} (missed webhook recovery)", | |
| expires_at=next_grant_date | |
| ) | |
| logger.info(f" ✅ Granted ${tier_info.monthly_credits} credits") | |
| fixed_count += 1 | |
| except Exception as e: | |
| logger.error(f"❌ Error processing {account_id}: {e}", exc_info=True) | |
| continue | |
| offset += batch_size | |
| if len(affected_users.data) < batch_size: | |
| break | |
| logger.info(f"\n{'[DRY RUN] ' if dry_run else ''}Summary:") | |
| logger.info(f" Total checked: {total_checked}") | |
| logger.info(f" Skipped: {skipped_count}") | |
| logger.info(f" Fixed: {fixed_count}") | |
| async def fix_renewals(target_date: str, dry_run: bool = False): | |
| """Fix users who should have received renewal credits on target date but didn't.""" | |
| logger.info("="*80) | |
| logger.info(f"FIXING MISSED RENEWALS FOR {target_date}") | |
| logger.info("="*80) | |
| db = DBConnection() | |
| await db.initialize() | |
| client = await db.client | |
| # Parse target date | |
| start_of_day = datetime.strptime(target_date, "%Y-%m-%d").replace(tzinfo=timezone.utc) | |
| end_of_day = start_of_day + timedelta(days=1) | |
| logger.info(f"Searching for users whose next_credit_grant was on {target_date} but weren't processed...") | |
| batch_size = 1000 | |
| offset = 0 | |
| fixed_count = 0 | |
| skipped_count = 0 | |
| total_checked = 0 | |
| while True: | |
| # Find users whose next_credit_grant was on target date | |
| # AND last_grant_date is NOT on target date (meaning they didn't get credited) | |
| affected_users = await client.from_('credit_accounts').select( | |
| 'account_id, tier, stripe_subscription_id, next_credit_grant, last_grant_date, balance' | |
| ).gte('next_credit_grant', start_of_day.isoformat()).lt( | |
| 'next_credit_grant', end_of_day.isoformat() | |
| ).not_.is_('stripe_subscription_id', 'null').not_.in_('tier', ['none', 'free']).range( | |
| offset, offset + batch_size - 1 | |
| ).execute() | |
| if not affected_users.data: | |
| break | |
| logger.info(f"\nBatch {offset//batch_size + 1}: Processing {len(affected_users.data)} users...") | |
| for user_data in affected_users.data: | |
| total_checked += 1 | |
| try: | |
| account_id = user_data['account_id'] | |
| tier_name = user_data['tier'] | |
| last_grant = user_data.get('last_grant_date') | |
| # Check if they already got credited on target date | |
| if last_grant: | |
| last_grant_date = datetime.fromisoformat(last_grant.replace('Z', '+00:00')) | |
| if start_of_day <= last_grant_date < end_of_day: | |
| # Already got credits | |
| skipped_count += 1 | |
| continue | |
| # Get tier info | |
| tier_info = get_tier_by_price_id(None) | |
| # We need to look up by tier name since we don't have price_id | |
| from core.billing.shared.config import get_tier_by_name | |
| tier_info = get_tier_by_name(tier_name) | |
| if not tier_info or not tier_info.monthly_refill_enabled: | |
| skipped_count += 1 | |
| continue | |
| # Fetch subscription to get current period | |
| current_sub_id = user_data.get('stripe_subscription_id') | |
| try: | |
| subscription = await stripe.Subscription.retrieve_async( | |
| current_sub_id, | |
| expand=['items.data.price'] | |
| ) | |
| except Exception as e: | |
| logger.warning(f"⚠️ Could not fetch subscription {current_sub_id} for {account_id}: {e}") | |
| skipped_count += 1 | |
| continue | |
| logger.info(f"{'[DRY RUN] ' if dry_run else ''}Granting missed renewal for {account_id}: {tier_info.name}, ${tier_info.monthly_credits}") | |
| if not dry_run: | |
| # Grant renewal credits | |
| next_grant_date = datetime.fromtimestamp(subscription.current_period_end, tz=timezone.utc) | |
| items = subscription.get('items') | |
| if items and items.get('data'): | |
| price_id = items['data'][0]['price']['id'] | |
| plan_type = get_plan_type(price_id) | |
| else: | |
| plan_type = 'monthly' | |
| if plan_type == 'yearly': | |
| billing_anchor = datetime.fromtimestamp(subscription.current_period_start, tz=timezone.utc) | |
| last_grant_dt = datetime.fromisoformat(last_grant.replace('Z', '+00:00')) if last_grant else billing_anchor | |
| next_grant_date = last_grant_dt + relativedelta(months=1) | |
| await credit_manager.add_credits( | |
| account_id=account_id, | |
| amount=tier_info.monthly_credits, | |
| is_expiring=True, | |
| description=f"Monthly renewal for {tier_info.display_name} (missed webhook recovery {target_date})", | |
| expires_at=next_grant_date | |
| ) | |
| # Update last processed | |
| await client.from_('credit_accounts').update({ | |
| 'last_grant_date': start_of_day.isoformat(), | |
| 'next_credit_grant': next_grant_date.isoformat() | |
| }).eq('account_id', account_id).execute() | |
| logger.info(f" ✅ Granted ${tier_info.monthly_credits} credits") | |
| fixed_count += 1 | |
| except Exception as e: | |
| logger.error(f"❌ Error processing {account_id}: {e}", exc_info=True) | |
| continue | |
| offset += batch_size | |
| if len(affected_users.data) < batch_size: | |
| break | |
| logger.info(f"\n{'[DRY RUN] ' if dry_run else ''}Summary:") | |
| logger.info(f" Total checked: {total_checked}") | |
| logger.info(f" Skipped: {skipped_count}") | |
| logger.info(f" Fixed: {fixed_count}") | |
| async def fix_upgrades(target_date: str, dry_run: bool = False): | |
| """Fix users whose actual Stripe subscription doesn't match their database tier.""" | |
| logger.info("="*80) | |
| logger.info(f"FIXING TIER MISMATCHES") | |
| logger.info("="*80) | |
| db = DBConnection() | |
| await db.initialize() | |
| client = await db.client | |
| logger.info("Searching for users whose DB tier doesn't match their Stripe subscription...") | |
| batch_size = 1000 | |
| offset = 0 | |
| fixed_count = 0 | |
| skipped_count = 0 | |
| total_checked = 0 | |
| while True: | |
| # Get all users with active subscriptions | |
| users = await client.from_('credit_accounts').select( | |
| 'account_id, tier, stripe_subscription_id' | |
| ).not_.is_('stripe_subscription_id', 'null').not_.in_('tier', ['none']).range( | |
| offset, offset + batch_size - 1 | |
| ).execute() | |
| if not users.data: | |
| break | |
| logger.info(f"\nBatch {offset//batch_size + 1}: Checking {len(users.data)} users...") | |
| for user_data in users.data: | |
| total_checked += 1 | |
| try: | |
| account_id = user_data['account_id'] | |
| db_tier = user_data['tier'] | |
| current_sub_id = user_data.get('stripe_subscription_id') | |
| # Fetch actual subscription from Stripe | |
| try: | |
| subscription = await stripe.Subscription.retrieve_async( | |
| current_sub_id, | |
| expand=['items.data.price'] | |
| ) | |
| except Exception as e: | |
| logger.warning(f"⚠️ Could not fetch subscription {current_sub_id} for {account_id}: {e}") | |
| skipped_count += 1 | |
| continue | |
| if subscription.status not in ['active', 'trialing', 'past_due']: | |
| skipped_count += 1 | |
| continue | |
| items = subscription.get('items') | |
| if not items or not items.get('data'): | |
| skipped_count += 1 | |
| continue | |
| price_id = items['data'][0]['price']['id'] | |
| tier_info = get_tier_by_price_id(price_id) | |
| if not tier_info: | |
| skipped_count += 1 | |
| continue | |
| # Check if tier matches | |
| if db_tier == tier_info.name: | |
| skipped_count += 1 | |
| continue | |
| logger.info(f"{'[DRY RUN] ' if dry_run else ''}Fixing tier mismatch for {account_id}: {db_tier} -> {tier_info.name}") | |
| if not dry_run: | |
| # Update tier | |
| billing_anchor = datetime.fromtimestamp(subscription.current_period_start, tz=timezone.utc) | |
| next_grant_date = datetime.fromtimestamp(subscription.current_period_end, tz=timezone.utc) | |
| plan_type = get_plan_type(price_id) | |
| if plan_type == 'yearly': | |
| next_grant_date = billing_anchor + relativedelta(months=1) | |
| await client.from_('credit_accounts').update({ | |
| 'tier': tier_info.name, | |
| 'plan_type': plan_type, | |
| 'billing_cycle_anchor': billing_anchor.isoformat(), | |
| 'next_credit_grant': next_grant_date.isoformat() | |
| }).eq('account_id', account_id).execute() | |
| # Replace credits if this was an upgrade | |
| if tier_info.monthly_refill_enabled: | |
| import time | |
| unique_id = f"upgrade_recovery_{account_id}_{tier_info.name}_{int(time.time())}" | |
| await credit_manager.reset_expiring_credits( | |
| account_id=account_id, | |
| new_credits=Decimal(str(tier_info.monthly_credits)), | |
| description=f"Tier correction to {tier_info.display_name} (missed webhook recovery)", | |
| stripe_event_id=unique_id | |
| ) | |
| logger.info(f" ✅ Updated credits to ${tier_info.monthly_credits}") | |
| fixed_count += 1 | |
| except Exception as e: | |
| logger.error(f"❌ Error processing {account_id}: {e}", exc_info=True) | |
| continue | |
| offset += batch_size | |
| if len(users.data) < batch_size: | |
| break | |
| logger.info(f"\n{'[DRY RUN] ' if dry_run else ''}Summary:") | |
| logger.info(f" Total checked: {total_checked}") | |
| logger.info(f" Skipped (already correct): {skipped_count}") | |
| logger.info(f" Fixed: {fixed_count}") | |
| async def main(): | |
| parser = argparse.ArgumentParser( | |
| description='Fix users affected by missed webhooks due to endpoint change', | |
| formatter_class=argparse.RawDescriptionHelpFormatter, | |
| epilog=""" | |
| Examples: | |
| # Dry run for all types | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --dry-run | |
| # Fix only new signups | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 --only signups | |
| # Fix all types for real | |
| uv run python core/utils/scripts/fix_missed_webhooks.py --date 2025-12-04 | |
| """ | |
| ) | |
| parser.add_argument( | |
| '--date', | |
| type=str, | |
| required=True, | |
| help='Date to process in YYYY-MM-DD format (e.g., 2025-12-04)' | |
| ) | |
| parser.add_argument( | |
| '--dry-run', | |
| action='store_true', | |
| help='Preview changes without applying them' | |
| ) | |
| parser.add_argument( | |
| '--only', | |
| type=str, | |
| choices=['signups', 'renewals', 'upgrades'], | |
| help='Only process specific type of affected users' | |
| ) | |
| args = parser.parse_args() | |
| logger.info("="*80) | |
| logger.info(f"MISSED WEBHOOK RECOVERY SCRIPT") | |
| logger.info(f"Date: {args.date}") | |
| logger.info(f"Mode: {'DRY RUN' if args.dry_run else 'LIVE'}") | |
| logger.info(f"Types: {args.only if args.only else 'ALL'}") | |
| logger.info("="*80) | |
| if args.dry_run: | |
| logger.info("\n⚠️ DRY RUN MODE - No changes will be made\n") | |
| try: | |
| if not args.only or args.only == 'signups': | |
| await fix_new_signups(args.date, args.dry_run) | |
| if not args.only or args.only == 'renewals': | |
| await fix_renewals(args.date, args.dry_run) | |
| if not args.only or args.only == 'upgrades': | |
| await fix_upgrades(args.date, args.dry_run) | |
| logger.info("\n" + "="*80) | |
| logger.info("✅ RECOVERY COMPLETE") | |
| logger.info("="*80) | |
| except Exception as e: | |
| logger.error(f"❌ Fatal error: {e}", exc_info=True) | |
| sys.exit(1) | |
| if __name__ == "__main__": | |
| asyncio.run(main()) | |