nniback / core /utils /scripts /fix_missed_webhooks.py
Kyrlos11's picture
Upload 842 files
22087d0 verified
Raw History Blame Contribute Delete
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())