diff --git a/app/templates/payment_success.html b/app/templates/payment_success.html
index 05bd9ba..d309da0 100644
--- a/app/templates/payment_success.html
+++ b/app/templates/payment_success.html
@@ -2,17 +2,110 @@
{% block content %}
-
-
Payment Successful!
-
- Thank you for your payment. Your VPN configuration will be sent to your email shortly.
-
-
- Please check your email for further instructions on setting up your VPN connection.
-
-
- Return to Home
-
+
+
Payment Successful!
+
+
+
+ Your VPN subscription is now active. Please follow the instructions below to set up your VPN connection.
+
+
+
+
+
+
+
Your WireGuard Configuration
+
+
+
+
+
+
+
Installation Instructions
+
+ - Download WireGuard for your platform:
+
+
+ - Create a new tunnel in WireGuard
+ - Copy the configuration above and paste it into the new tunnel
+ - Activate the tunnel to connect
+
+
+
+
+
• Save your configuration securely - you'll need it to reconnect
+
• Your private key is stored in your browser's local storage
+
• For security, clear your browser data after saving the configuration
+
+
+
+
+
+
{% endblock %}
\ No newline at end of file
diff --git a/app/utils/db/__init__.py b/app/utils/db/__init__.py
new file mode 100644
index 0000000..8fdadd7
--- /dev/null
+++ b/app/utils/db/__init__.py
@@ -0,0 +1,23 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from pathlib import Path
+
+def get_db_path():
+ base_dir = Path(__file__).resolve().parent.parent.parent
+ data_dir = base_dir / 'data'
+ data_dir.mkdir(exist_ok=True)
+ return data_dir / 'vpn.db'
+
+def init_db():
+ """Initialize the database"""
+ from .models import Base
+ db_url = f"sqlite:///{get_db_path()}"
+ engine = create_engine(db_url)
+ Base.metadata.create_all(engine)
+ return engine
+
+def get_session():
+ """Get a database session"""
+ engine = init_db()
+ Session = sessionmaker(bind=engine)
+ return Session()
\ No newline at end of file
diff --git a/app/utils/db/models.py b/app/utils/db/models.py
new file mode 100644
index 0000000..9390fda
--- /dev/null
+++ b/app/utils/db/models.py
@@ -0,0 +1,52 @@
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, ForeignKey, Enum, Text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+import enum
+import datetime
+
+Base = declarative_base()
+
+class SubscriptionStatus(enum.Enum):
+ ACTIVE = "active"
+ EXPIRED = "expired"
+ PENDING = "pending"
+ CANCELLED = "cancelled"
+
+class User(Base):
+ __tablename__ = 'users'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(String, unique=True, nullable=False) # UUID generated in frontend
+ created_at = Column(DateTime, default=datetime.datetime.utcnow)
+
+ subscriptions = relationship("Subscription", back_populates="user")
+ payments = relationship("Payment", back_populates="user")
+
+class Subscription(Base):
+ __tablename__ = 'subscriptions'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(Integer, ForeignKey('users.id'))
+ invoice_id = Column(String, unique=True)
+ public_key = Column(Text, nullable=False) # WireGuard public key
+ start_time = Column(DateTime, nullable=False)
+ expiry_time = Column(DateTime, nullable=False)
+ status = Column(Enum(SubscriptionStatus), default=SubscriptionStatus.PENDING)
+ warning_sent = Column(Integer, default=0)
+ assigned_ip = Column(String) # WireGuard IP address assigned to this subscription
+
+ user = relationship("User", back_populates="subscriptions")
+ payments = relationship("Payment", back_populates="subscription")
+
+class Payment(Base):
+ __tablename__ = 'payments'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(Integer, ForeignKey('users.id'))
+ subscription_id = Column(Integer, ForeignKey('subscriptions.id'))
+ invoice_id = Column(String, unique=True)
+ amount = Column(Integer, nullable=False) # Amount in sats
+ timestamp = Column(DateTime, default=datetime.datetime.utcnow)
+
+ user = relationship("User", back_populates="payments")
+ subscription = relationship("Subscription", back_populates="payments")
\ No newline at end of file
diff --git a/app/utils/db/operations.py b/app/utils/db/operations.py
new file mode 100644
index 0000000..e5f00f5
--- /dev/null
+++ b/app/utils/db/operations.py
@@ -0,0 +1,152 @@
+from datetime import datetime
+from sqlalchemy.exc import SQLAlchemyError
+from . import get_session
+from .models import User, Subscription, Payment, SubscriptionStatus
+import logging
+import ipaddress
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+ @staticmethod
+ def get_next_available_ip():
+ """Get the next available IP from the WireGuard subnet"""
+ with get_session() as session:
+ # Get all assigned IPs
+ assigned_ips = session.query(Subscription.assigned_ip)\
+ .filter(Subscription.assigned_ip.isnot(None))\
+ .all()
+ assigned_ips = [ip[0] for ip in assigned_ips]
+
+ # Start from 10.8.0.2 (10.8.0.1 is server)
+ network = ipaddress.IPv4Network('10.8.0.0/24')
+ for ip in network.hosts():
+ str_ip = str(ip)
+ if str_ip == '10.8.0.1': # Skip server IP
+ continue
+ if str_ip not in assigned_ips:
+ return str_ip
+
+ raise Exception("No available IPs in the subnet")
+
+ @staticmethod
+ def create_user(user_id):
+ """Create a new user with UUID"""
+ with get_session() as session:
+ user = User(user_id=user_id)
+ session.add(user)
+ session.commit()
+ return user
+
+ @staticmethod
+ def get_user_by_uuid(user_id):
+ """Get user by UUID"""
+ with get_session() as session:
+ return session.query(User).filter(User.user_id == user_id).first()
+
+ @staticmethod
+ def get_subscription_by_invoice(invoice_id):
+ """Get subscription by invoice ID"""
+ with get_session() as session:
+ return session.query(Subscription)\
+ .filter(Subscription.invoice_id == invoice_id)\
+ .first()
+
+ @staticmethod
+ def create_subscription(user_id, invoice_id, public_key, duration_hours):
+ """Create a new subscription"""
+ with get_session() as session:
+ try:
+ # Get user or create if doesn't exist
+ user = DatabaseManager.get_user_by_uuid(user_id)
+ if not user:
+ user = DatabaseManager.create_user(user_id)
+
+ start_time = datetime.utcnow()
+ expiry_time = start_time + datetime.timedelta(hours=duration_hours)
+
+ # Get next available IP
+ assigned_ip = DatabaseManager.get_next_available_ip()
+
+ subscription = Subscription(
+ user_id=user.id,
+ invoice_id=invoice_id,
+ public_key=public_key,
+ start_time=start_time,
+ expiry_time=expiry_time,
+ status=SubscriptionStatus.PENDING,
+ assigned_ip=assigned_ip
+ )
+ session.add(subscription)
+ session.commit()
+ return subscription
+ except Exception as e:
+ logger.error(f"Error creating subscription: {str(e)}")
+ session.rollback()
+ raise
+
+ @staticmethod
+ def activate_subscription(invoice_id):
+ """Activate a subscription after payment"""
+ with get_session() as session:
+ subscription = session.query(Subscription)\
+ .filter(Subscription.invoice_id == invoice_id)\
+ .first()
+
+ if subscription:
+ subscription.status = SubscriptionStatus.ACTIVE
+ session.commit()
+ return subscription
+
+ @staticmethod
+ def record_payment(user_id, subscription_id, invoice_id, amount):
+ """Record a payment"""
+ with get_session() as session:
+ user = DatabaseManager.get_user_by_uuid(user_id)
+ if not user:
+ raise ValueError(f"User {user_id} not found")
+
+ payment = Payment(
+ user_id=user.id,
+ subscription_id=subscription_id,
+ invoice_id=invoice_id,
+ amount=amount
+ )
+ session.add(payment)
+ session.commit()
+ return payment
+
+ @staticmethod
+ def get_active_subscriptions():
+ """Get all active subscriptions"""
+ with get_session() as session:
+ return session.query(Subscription)\
+ .filter(Subscription.status == SubscriptionStatus.ACTIVE)\
+ .all()
+
+ @staticmethod
+ def expire_subscription(subscription_id):
+ """Mark a subscription as expired"""
+ with get_session() as session:
+ subscription = session.query(Subscription)\
+ .filter(Subscription.id == subscription_id)\
+ .first()
+
+ if subscription:
+ subscription.status = SubscriptionStatus.EXPIRED
+ session.commit()
+ return True
+ return False
+
+ @staticmethod
+ def update_warning_sent(subscription_id):
+ """Update the warning_sent flag for a subscription"""
+ with get_session() as session:
+ subscription = session.query(Subscription)\
+ .filter(Subscription.id == subscription_id)\
+ .first()
+ if subscription:
+ subscription.warning_sent = 1
+ session.commit()
+ return True
+ return False
\ No newline at end of file
diff --git a/app/utils/db/utils.py b/app/utils/db/utils.py
new file mode 100644
index 0000000..17f1e58
--- /dev/null
+++ b/app/utils/db/utils.py
@@ -0,0 +1,59 @@
+import sqlite3
+import shutil
+from datetime import datetime
+from pathlib import Path
+import logging
+from .. import get_db_path
+
+logger = logging.getLogger(__name__)
+
+def backup_database():
+ """Create a backup of the SQLite database"""
+ try:
+ db_path = get_db_path()
+ if not db_path.exists():
+ logger.error("Database file not found")
+ return False
+
+ backup_dir = db_path.parent / 'backups'
+ backup_dir.mkdir(exist_ok=True)
+
+ timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+ backup_path = backup_dir / f'vpn_db_backup_{timestamp}.db'
+
+ shutil.copy2(db_path, backup_path)
+ logger.info(f"Database backed up successfully to {backup_path}")
+
+ # Keep only last 5 backups
+ backups = sorted(backup_dir.glob('vpn_db_backup_*.db'))
+ if len(backups) > 5:
+ for old_backup in backups[:-5]:
+ old_backup.unlink()
+ logger.info(f"Removed old backup: {old_backup}")
+
+ return True
+
+ except Exception as e:
+ logger.error(f"Backup failed: {str(e)}")
+ return False
+
+def verify_database():
+ """Check database integrity"""
+ try:
+ db_path = get_db_path()
+ conn = sqlite3.connect(db_path)
+ cursor = conn.cursor()
+
+ cursor.execute("PRAGMA integrity_check")
+ result = cursor.fetchone()[0]
+
+ if result != "ok":
+ logger.error(f"Database integrity check failed: {result}")
+ return False
+
+ logger.info("Database integrity verified")
+ return True
+
+ except Exception as e:
+ logger.error(f"Database verification failed: {str(e)}")
+ return False
\ No newline at end of file
diff --git a/data/vpn.db b/data/vpn.db
new file mode 100644
index 0000000..6ab8f2a
Binary files /dev/null and b/data/vpn.db differ
diff --git a/requirements.txt b/requirements.txt
index 99ca526..5e36ecb 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,4 +3,5 @@ pyyaml==6.0.1
python-dotenv==1.0.0
cryptography==41.0.7
ansible==9.1.0
-requests==2.31.0
\ No newline at end of file
+requests==2.31.0
+SQLAlchemy==2.0.25
\ No newline at end of file
diff --git a/scripts/init_db.py b/scripts/init_db.py
new file mode 100644
index 0000000..cb7649e
--- /dev/null
+++ b/scripts/init_db.py
@@ -0,0 +1,28 @@
+# scripts/init_db.py
+import sys
+from pathlib import Path
+
+# Add the project root to Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.append(str(project_root))
+
+from app.utils.db.models import Base
+from sqlalchemy import create_engine
+
+def init_db():
+ # Create data directory if it doesn't exist
+ data_dir = project_root / 'data'
+ data_dir.mkdir(exist_ok=True)
+
+ # Create database
+ db_path = data_dir / 'vpn.db'
+ db_url = f"sqlite:///{db_path}"
+ engine = create_engine(db_url)
+
+ # Create all tables
+ Base.metadata.create_all(engine)
+ print(f"Database initialized at: {db_path}")
+ return engine
+
+if __name__ == "__main__":
+ init_db()
\ No newline at end of file
diff --git a/scripts/migrate_db.py b/scripts/migrate_db.py
new file mode 100644
index 0000000..4e68743
--- /dev/null
+++ b/scripts/migrate_db.py
@@ -0,0 +1,151 @@
+import sys
+from pathlib import Path
+import sqlite3
+import uuid
+import logging
+from datetime import datetime
+
+# Add the project root to Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.append(str(project_root))
+
+from app.utils.db.models import Base, SubscriptionStatus
+from app.utils.db import get_db_path, get_session
+from sqlalchemy import create_engine
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def backup_database():
+ """Create a backup of the existing database"""
+ db_path = get_db_path()
+ if not db_path.exists():
+ logger.info("No existing database found, skipping backup")
+ return
+
+ backup_path = db_path.parent / f"{db_path.stem}_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}{db_path.suffix}"
+ db_path.rename(backup_path)
+ logger.info(f"Created database backup at {backup_path}")
+ return backup_path
+
+def migrate_database():
+ """Perform database migration"""
+ try:
+ # Create backup
+ backup_path = backup_database()
+
+ # Initialize new database
+ engine = create_engine(f"sqlite:///{get_db_path()}")
+ Base.metadata.create_all(engine)
+
+ # If there's an old database, migrate the data
+ if backup_path and backup_path.exists():
+ logger.info("Migrating data from old database...")
+
+ # Connect to old database
+ old_conn = sqlite3.connect(backup_path)
+ old_cursor = old_conn.cursor()
+
+ # Get schema information
+ old_cursor.execute("SELECT sql FROM sqlite_master WHERE type='table'")
+ old_schema = old_cursor.fetchall()
+ logger.info("Old database schema:")
+ for table in old_schema:
+ logger.info(table[0])
+
+ with get_session() as session:
+ try:
+ # Start transaction
+ session.begin()
+
+ # Migrate users
+ logger.info("Migrating users...")
+ old_cursor.execute("SELECT id, email, created_at FROM users")
+ users = old_cursor.fetchall()
+ user_id_map = {} # Map old IDs to new UUIDs
+
+ for old_id, email, created_at in users:
+ new_user_id = str(uuid.uuid4())
+ user_id_map[old_id] = new_user_id
+ session.execute(
+ "INSERT INTO users (user_id, created_at) VALUES (?, ?)",
+ [new_user_id, created_at or datetime.utcnow()]
+ )
+
+ # Migrate subscriptions
+ logger.info("Migrating subscriptions...")
+ old_cursor.execute("""
+ SELECT id, user_id, invoice_id, start_time, expiry_time,
+ status, warning_sent
+ FROM subscriptions
+ """)
+ subscriptions = old_cursor.fetchall()
+
+ for sub in subscriptions:
+ old_id, old_user_id, invoice_id, start_time, expiry_time, status, warning_sent = sub
+ if old_user_id in user_id_map:
+ # Generate a placeholder public key for existing subscriptions
+ placeholder_pubkey = f"MIGRATED_{uuid.uuid4()}"
+ session.execute("""
+ INSERT INTO subscriptions
+ (user_id, invoice_id, public_key, start_time, expiry_time,
+ status, warning_sent, assigned_ip)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ """, [
+ user_id_map[old_user_id],
+ invoice_id,
+ placeholder_pubkey,
+ start_time,
+ expiry_time,
+ status,
+ warning_sent,
+ f"10.8.0.{2 + old_id}" # Simple IP assignment
+ ])
+
+ # Migrate payments
+ logger.info("Migrating payments...")
+ old_cursor.execute("""
+ SELECT user_id, subscription_id, invoice_id, amount, timestamp
+ FROM payments
+ """)
+ payments = old_cursor.fetchall()
+
+ for payment in payments:
+ old_user_id, sub_id, invoice_id, amount, timestamp = payment
+ if old_user_id in user_id_map:
+ session.execute("""
+ INSERT INTO payments
+ (user_id, subscription_id, invoice_id, amount, timestamp)
+ VALUES (?, ?, ?, ?, ?)
+ """, [
+ user_id_map[old_user_id],
+ sub_id,
+ invoice_id,
+ amount,
+ timestamp
+ ])
+
+ # Commit transaction
+ session.commit()
+ logger.info("Migration completed successfully")
+
+ except Exception as e:
+ session.rollback()
+ logger.error(f"Migration failed: {str(e)}")
+ raise
+
+ old_conn.close()
+
+ else:
+ logger.info("No existing database to migrate")
+
+ except Exception as e:
+ logger.error(f"Migration failed: {str(e)}")
+ raise
+
+if __name__ == '__main__':
+ try:
+ migrate_database()
+ except Exception as e:
+ logger.error(f"Migration failed: {str(e)}")
+ sys.exit(1)
\ No newline at end of file
diff --git a/scripts/subscription_checker.py b/scripts/subscription_checker.py
index e3c3acc..9e6f368 100644
--- a/scripts/subscription_checker.py
+++ b/scripts/subscription_checker.py
@@ -1,14 +1,12 @@
-# scripts/subscription_checker.py
-
-import json
-import datetime
import logging
import subprocess
import os
import tempfile
from pathlib import Path
-from dateutil.parser import parse
-from dateutil.relativedelta import relativedelta
+from datetime import datetime, timedelta
+from utils.db.operations import DatabaseManager
+from utils.db.models import SubscriptionStatus
+from app.handlers.payment_handler import BTCPayHandler
logging.basicConfig(
level=logging.INFO,
@@ -19,20 +17,19 @@ logger = logging.getLogger(__name__)
# Path setup
SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_ROOT = SCRIPT_DIR.parent
-SUBSCRIPTION_DB = PROJECT_ROOT / 'data' / 'subscriptions.json'
CLEANUP_PLAYBOOK = PROJECT_ROOT / 'ansible' / 'playbooks' / 'vpn_cleanup.yml'
INVENTORY_FILE = PROJECT_ROOT / 'inventory.ini'
# Notification thresholds configuration
NOTIFICATION_THRESHOLDS = {
- 'minimum_duration': datetime.timedelta(hours=1), # Minimum subscription duration
+ 'minimum_duration': timedelta(hours=1), # Minimum subscription duration
'short_term': {
- 'max_duration': datetime.timedelta(days=1),
+ 'max_duration': timedelta(days=1),
'warning_fraction': 0.5, # Warn when 50% of time remains
'grace_fraction': 0.1 # Grace period of 10% of subscription length
},
'medium_term': {
- 'max_duration': datetime.timedelta(days=7),
+ 'max_duration': timedelta(days=7),
'warning_fraction': 0.25, # Warn when 25% of time remains
'grace_hours': 12 # Fixed 12-hour grace period
},
@@ -42,25 +39,9 @@ NOTIFICATION_THRESHOLDS = {
}
}
-def load_subscriptions():
- """Load subscription data from JSON file"""
- if not SUBSCRIPTION_DB.parent.exists():
- SUBSCRIPTION_DB.parent.mkdir(parents=True)
-
- if not SUBSCRIPTION_DB.exists():
- return {}
-
- with open(SUBSCRIPTION_DB, 'r') as f:
- return json.load(f)
-
-def save_subscriptions(subscriptions):
- """Save subscriptions to JSON file"""
- with open(SUBSCRIPTION_DB, 'w') as f:
- json.dump(subscriptions, f, indent=2)
-
-def run_cleanup_playbook(sub_id):
+def run_cleanup_playbook(subscription_id):
"""Run the VPN cleanup playbook"""
- logger.info(f"Running cleanup playbook for subscription {sub_id}")
+ logger.info(f"Running cleanup playbook for subscription {subscription_id}")
vault_pass = os.getenv('ANSIBLE_VAULT_PASSWORD', '')
if not vault_pass:
@@ -74,7 +55,7 @@ def run_cleanup_playbook(sub_id):
'ansible-playbook',
str(CLEANUP_PLAYBOOK),
'-i', str(INVENTORY_FILE),
- '-e', f'subscription_id={sub_id}',
+ '-e', f'subscription_id={subscription_id}',
'--vault-password-file', vault_pass_file.name,
'-vvv'
]
@@ -122,42 +103,36 @@ def calculate_notification_times(start_time, end_time):
warning_delta = duration * NOTIFICATION_THRESHOLDS['medium_term']['warning_fraction']
grace_hours = NOTIFICATION_THRESHOLDS['medium_term']['grace_hours']
warning_time = end_time - warning_delta
- grace_end_time = end_time + datetime.timedelta(hours=grace_hours)
+ grace_end_time = end_time + timedelta(hours=grace_hours)
# Long-term subscriptions (> 7 days)
else:
warning_days = NOTIFICATION_THRESHOLDS['long_term']['warning_days']
grace_days = NOTIFICATION_THRESHOLDS['long_term']['grace_days']
- warning_time = end_time - datetime.timedelta(days=warning_days)
- grace_end_time = end_time + datetime.timedelta(days=grace_days)
+ warning_time = end_time - timedelta(days=warning_days)
+ grace_end_time = end_time + timedelta(days=grace_days)
return warning_time, grace_end_time
-def get_notification_message(sub_data, remaining_time):
+def get_notification_message(subscription, remaining_time):
"""Generate appropriate notification message based on subscription duration"""
- if remaining_time < datetime.timedelta(hours=1):
+ if remaining_time < timedelta(hours=1):
return f"Your VPN subscription expires in {int(remaining_time.total_seconds() / 60)} minutes!"
- elif remaining_time < datetime.timedelta(days=1):
+ elif remaining_time < timedelta(days=1):
return f"Your VPN subscription expires in {int(remaining_time.total_seconds() / 3600)} hours!"
else:
return f"Your VPN subscription expires in {remaining_time.days} days!"
-def notify_user(user_id, message):
+def notify_user(subscription, message):
"""Send notification to user about subscription status"""
try:
- subscriptions = load_subscriptions()
- sub_data = subscriptions.get(user_id)
-
- if not sub_data or 'email' not in sub_data:
- logger.error(f"No email found for user {user_id}")
+ if not subscription.user or not subscription.user.email:
+ logger.error(f"No email found for subscription {subscription.id}")
return False
-
- # Import BTCPayHandler here to avoid circular imports
- from app.handlers.payment_handler import BTCPayHandler
btcpay_handler = BTCPayHandler()
email_sent = btcpay_handler.send_confirmation_email(
- sub_data['email'],
+ subscription.user.email,
f"""
VPN Subscription Update
@@ -168,9 +143,9 @@ def notify_user(user_id, message):
)
if email_sent:
- logger.info(f"Sent notification to {sub_data['email']}: {message}")
+ logger.info(f"Sent notification to {subscription.user.email}: {message}")
else:
- logger.warning(f"Failed to send notification to {sub_data['email']}")
+ logger.warning(f"Failed to send notification to {subscription.user.email}")
return email_sent
@@ -182,68 +157,64 @@ def check_subscriptions():
"""Check subscription status and clean up expired ones"""
logger.info("Starting subscription check")
- subscriptions = load_subscriptions()
- now = datetime.datetime.now()
- modified = False
-
- logger.info(f"Checking {len(subscriptions)} subscriptions")
-
- for sub_id, sub_data in list(subscriptions.items()):
- try:
- logger.debug(f"Processing subscription {sub_id}")
-
- if sub_data.get('status') != 'Active':
- logger.debug(f"Skipping inactive subscription {sub_id}")
- continue
+ try:
+ active_subscriptions = DatabaseManager.get_active_subscriptions()
+ logger.info(f"Checking {len(active_subscriptions)} active subscriptions")
+
+ now = datetime.utcnow()
+
+ for subscription in active_subscriptions:
+ try:
+ logger.debug(f"Processing subscription {subscription.id}")
- start_time = parse(sub_data['start_time'])
- expiry = parse(sub_data['expiry'])
- warning_time, grace_end_time = calculate_notification_times(start_time, expiry)
-
- # Calculate remaining time
- remaining_time = expiry - now
- logger.debug(f"Subscription {sub_id} has {remaining_time} remaining")
-
- # Handle warnings
- if now >= warning_time and not sub_data.get('warning_sent'):
- message = get_notification_message(sub_data, remaining_time)
- logger.info(f"Sending notification for subscription {sub_id}: {message}")
+ warning_time, grace_end_time = calculate_notification_times(
+ subscription.start_time,
+ subscription.expiry_time
+ )
- notify_user(sub_id, message)
+ # Calculate remaining time
+ remaining_time = subscription.expiry_time - now
+ logger.debug(f"Subscription {subscription.id} has {remaining_time} remaining")
- sub_data['warning_sent'] = True
- modified = True
-
- # Handle expiration
- if now >= grace_end_time and sub_data.get('status') == 'Active':
- logger.info(f"Processing expiration for subscription {sub_id}")
-
- try:
- logger.debug(f"Running cleanup playbook for {sub_id}")
- result = run_cleanup_playbook(sub_id)
+ # Handle warnings
+ if now >= warning_time and not subscription.warning_sent:
+ message = get_notification_message(subscription, remaining_time)
+ logger.info(f"Sending notification for subscription {subscription.id}: {message}")
- if result.returncode == 0:
- sub_data['status'] = 'Expired'
- sub_data['cleanup_date'] = now.isoformat()
- modified = True
- logger.info(f"Successfully cleaned up subscription {sub_id}")
- else:
- logger.error(f"Cleanup failed: {result.stderr}")
+ if notify_user(subscription, message):
+ DatabaseManager.update_warning_sent(subscription.id)
+
+ # Handle expiration
+ if now >= grace_end_time:
+ logger.info(f"Processing expiration for subscription {subscription.id}")
+
+ try:
+ result = run_cleanup_playbook(subscription.invoice_id)
- except Exception as e:
- logger.error(f"Error during cleanup: {str(e)}")
- logger.error(traceback.format_exc())
-
- except Exception as e:
- logger.error(f"Error processing subscription {sub_id}: {str(e)}")
- logger.error(traceback.format_exc())
- continue
-
- if modified:
- save_subscriptions(subscriptions)
- logger.info("Updated subscription database")
-
- logger.info("Subscription check completed")
+ if result.returncode == 0:
+ DatabaseManager.expire_subscription(subscription.id)
+ logger.info(f"Successfully cleaned up subscription {subscription.id}")
+
+ # Send final notification
+ notify_user(subscription, "Your VPN subscription has expired and been deactivated.")
+ else:
+ logger.error(f"Cleanup failed: {result.stderr}")
+
+ except Exception as e:
+ logger.error(f"Error during cleanup: {str(e)}")
+ logger.error(traceback.format_exc())
+
+ except Exception as e:
+ logger.error(f"Error processing subscription {subscription.id}: {str(e)}")
+ logger.error(traceback.format_exc())
+ continue
+
+ logger.info("Subscription check completed")
+
+ except Exception as e:
+ logger.error(f"Subscription checker failed: {str(e)}")
+ logger.error(traceback.format_exc())
+ raise
if __name__ == '__main__':
try:
diff --git a/venv/include/site/python3.11/greenlet/greenlet.h b/venv/include/site/python3.11/greenlet/greenlet.h
new file mode 100644
index 0000000..d02a16e
--- /dev/null
+++ b/venv/include/site/python3.11/greenlet/greenlet.h
@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+ PyObject_HEAD
+ PyObject* weakreflist;
+ PyObject* dict;
+ implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+# define PyGreenlet_Type \
+ (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+# define PyExc_GreenletError \
+ ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+# define PyExc_GreenletExit \
+ ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+# define PyGreenlet_New \
+ (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+ _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+# define PyGreenlet_GetCurrent \
+ (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ * PyGreenlet *greenlet,
+ * PyObject *typ,
+ * PyObject *val,
+ * PyObject *tb)
+ *
+ * g.throw(...)
+ */
+# define PyGreenlet_Throw \
+ (*(PyObject * (*)(PyGreenlet * self, \
+ PyObject * typ, \
+ PyObject * val, \
+ PyObject * tb)) \
+ _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+# define PyGreenlet_Switch \
+ (*(PyObject * \
+ (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+ _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+# define PyGreenlet_SetParent \
+ (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+ _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+# define PyGreenlet_GetParent \
+ (*(PyGreenlet* (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+# define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+# define PyGreenlet_MAIN \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+# define PyGreenlet_STARTED \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+# define PyGreenlet_ACTIVE \
+ (*(int (*)(PyGreenlet*)) \
+ _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+ keep the older definition to be sure older code that might have a copy of
+ the header still works. */
+# define PyGreenlet_Import() \
+ { \
+ _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+ }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */