django-cfg 1.2.31__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/apps/payments/managers/payment_manager.py

@@ -1,192 +0,0 @@
-"""
-Enhanced Payment manager for UniversalPayment model with query optimizations.
-"""
-
-from django.db import models
-from django.utils import timezone
-from datetime import timedelta
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger("payment_manager")
-
-
-class PaymentQuerySet(models.QuerySet):
-    """Custom QuerySet for UniversalPayment with optimizations."""
-    
-    def with_user(self):
-        """Select related user to prevent N+1 queries."""
-        return self.select_related('user')
-    
-    def with_events(self):
-        """Skip prefetch for events since they use CharField payment_id, not ForeignKey."""
-        # PaymentEvent uses CharField payment_id, not ForeignKey, so no reverse relation exists
-        # Events should be fetched separately when needed
-        return self
-    
-    def optimized(self):
-        """Get optimized queryset for admin and API views."""
-        return self.select_related('user').with_events()
-    
-    def active(self):
-        """Get active payments (not failed, cancelled, or refunded)."""
-        return self.exclude(
-            status__in=['failed', 'cancelled', 'refunded', 'expired']
-        )
-    
-    def completed(self):
-        """Get only completed payments."""
-        return self.filter(status='completed')
-    
-    def pending(self):
-        """Get pending payments."""
-        return self.filter(status='pending')
-    
-    def by_provider(self, provider):
-        """Filter by payment provider."""
-        return self.filter(provider=provider)
-    
-    def recent(self, days=30):
-        """Get payments from last N days."""
-        cutoff_date = timezone.now() - timedelta(days=days)
-        return self.filter(created_at__gte=cutoff_date)
-    
-    def by_amount_range(self, min_amount=None, max_amount=None):
-        """Filter by USD amount range."""
-        queryset = self
-        if min_amount is not None:
-            queryset = queryset.filter(amount_usd__gte=min_amount)
-        if max_amount is not None:
-            queryset = queryset.filter(amount_usd__lte=max_amount)
-        return queryset
-    
-    def by_user(self, user):
-        """Filter by user."""
-        return self.filter(user=user)
-    
-    def expired(self):
-        """Get expired payments."""
-        return self.filter(
-            expires_at__lt=timezone.now(),
-            status__in=['pending', 'confirming']
-        )
-
-
-class UniversalPaymentManager(models.Manager):
-    """Enhanced manager for UniversalPayment with optimization methods."""
-    
-    def get_queryset(self):
-        """Return custom QuerySet."""
-        return PaymentQuerySet(self.model, using=self._db)
-    
-    def with_user(self):
-        """Get payments with user data preloaded."""
-        return self.get_queryset().with_user()
-    
-    def optimized(self):
-        """Get optimized queryset for admin views."""
-        return self.get_queryset().optimized()
-    
-    def active(self):
-        """Get active payments."""
-        return self.get_queryset().active()
-    
-    def completed(self):
-        """Get completed payments."""
-        return self.get_queryset().completed()
-    
-    def pending(self):
-        """Get pending payments."""
-        return self.get_queryset().pending()
-    
-    def recent(self, days=30):
-        """Get recent payments."""
-        return self.get_queryset().recent(days)
-    
-    def by_provider(self, provider):
-        """Get payments by provider."""
-        return self.get_queryset().by_provider(provider)
-    
-    def create_payment(self, user, amount_usd: float, currency_code: str, provider: str, **kwargs):
-        """Create a payment with automatic field generation."""
-        from uuid import uuid4
-        
-        # Generate unique internal payment ID if not provided
-        internal_payment_id = kwargs.pop('internal_payment_id', f"PAY_{uuid4().hex[:8].upper()}")
-        
-        payment = self.create(
-            user=user,
-            internal_payment_id=internal_payment_id,
-            amount_usd=amount_usd,
-            currency_code=currency_code.upper(),
-            provider=provider,
-            status=self.model.PaymentStatus.PENDING,
-            **kwargs
-        )
-        
-        return payment
-    
-    def get_pending_payments(self, user=None):
-        """Get pending payments for user or all users."""
-        queryset = self.pending()
-        if user:
-            queryset = queryset.by_user(user)
-        return queryset.with_user()
-    
-    def get_completed_payments(self, user=None):
-        """Get completed payments for user or all users."""
-        queryset = self.completed()
-        if user:
-            queryset = queryset.by_user(user)
-        return queryset.with_user()
-    
-    def get_failed_payments(self, user=None):
-        """Get failed/expired payments for user or all users."""
-        queryset = self.filter(status__in=[
-            self.model.PaymentStatus.FAILED, 
-            self.model.PaymentStatus.EXPIRED
-        ])
-        if user:
-            queryset = queryset.by_user(user)
-        return queryset.with_user()
-    
-    def get_user_stats(self, user):
-        """Get payment statistics for a user."""
-        user_payments = self.by_user(user)
-        
-        return {
-            'total_payments': user_payments.count(),
-            'completed_payments': user_payments.completed().count(),
-            'pending_payments': user_payments.pending().count(),
-            'failed_payments': user_payments.filter(status='failed').count(),
-            'total_amount_usd': user_payments.completed().aggregate(
-                total=models.Sum('amount_usd')
-            )['total'] or 0,
-            'recent_payments_30d': user_payments.recent(30).count(),
-        }
-    
-    def get_provider_stats(self, provider=None):
-        """Get payment statistics by provider."""
-        if provider:
-            payments = self.by_provider(provider)
-        else:
-            payments = self.all()
-        
-        return {
-            'total_payments': payments.count(),
-            'completed_payments': payments.completed().count(),
-            'pending_payments': payments.pending().count(),
-            'success_rate': (
-                payments.completed().count() / max(payments.count(), 1) * 100
-            ),
-            'total_volume_usd': payments.completed().aggregate(
-                total=models.Sum('amount_usd')
-            )['total'] or 0,
-        }
-    
-    def mark_expired_payments(self):
-        """Mark expired payments as expired."""
-        expired_count = self.expired().update(
-            status=self.model.PaymentStatus.EXPIRED,
-            updated_at=timezone.now()
-        )
-        return expired_count

django_cfg/apps/payments/managers/subscription_manager.py

@@ -1,37 +0,0 @@
-"""
-Subscription managers.
-"""
-
-from django.db import models
-from django.utils import timezone
-
-
-class SubscriptionManager(models.Manager):
-    """Manager for Subscription model."""
-    
-    def get_active_subscriptions(self, user=None):
-        """Get active subscriptions."""
-        queryset = self.filter(
-            status='active',
-            expires_at__gt=timezone.now()
-        )
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-    
-    def get_expired_subscriptions(self, user=None):
-        """Get expired subscriptions."""
-        queryset = self.filter(
-            expires_at__lte=timezone.now()
-        )
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-
-
-class EndpointGroupManager(models.Manager):
-    """Manager for EndpointGroup model."""
-    
-    def get_active_groups(self):
-        """Get active endpoint groups."""
-        return self.filter(is_active=True)

django_cfg/apps/payments/managers/tariff_manager.py

@@ -1,29 +0,0 @@
-"""
-Tariff managers.
-"""
-
-from django.db import models
-
-
-class TariffManager(models.Manager):
-    """Manager for Tariff model."""
-    
-    def get_active_tariffs(self):
-        """Get active tariffs."""
-        return self.filter(is_active=True).order_by('monthly_price')
-    
-    def get_free_tariffs(self):
-        """Get free tariffs."""
-        return self.filter(monthly_price=0, is_active=True)
-    
-    def get_paid_tariffs(self):
-        """Get paid tariffs."""
-        return self.filter(monthly_price__gt=0, is_active=True)
-
-
-class TariffEndpointGroupManager(models.Manager):
-    """Manager for TariffEndpointGroup model."""
-    
-    def get_enabled_for_tariff(self, tariff):
-        """Get enabled endpoint groups for tariff."""
-        return self.filter(tariff=tariff, is_enabled=True)

django_cfg/apps/payments/migrations/0002_network_providercurrency_and_more.py

@@ -1,241 +0,0 @@
-# Generated by Django 5.2.6 on 2025-09-24 19:54
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("django_cfg_payments", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Network",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
-                    ),
-                ),
-                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
-                ("updated_at", models.DateTimeField(auto_now=True)),
-                (
-                    "code",
-                    models.CharField(
-                        help_text="Network code: ethereum, bitcoin, tron, bsc",
-                        max_length=20,
-                        unique=True,
-                    ),
-                ),
-                (
-                    "name",
-                    models.CharField(
-                        help_text="Network name: Ethereum, Bitcoin, TRON, BSC", max_length=100
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "Network",
-                "verbose_name_plural": "Networks",
-                "db_table": "payment_networks",
-                "ordering": ["name"],
-            },
-        ),
-        migrations.CreateModel(
-            name="ProviderCurrency",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
-                    ),
-                ),
-                ("created_at", models.DateTimeField(auto_now_add=True, db_index=True)),
-                ("updated_at", models.DateTimeField(auto_now=True)),
-                (
-                    "provider_name",
-                    models.CharField(
-                        help_text="Provider: nowpayments, stripe, cryptomus", max_length=50
-                    ),
-                ),
-                (
-                    "provider_currency_code",
-                    models.CharField(
-                        help_text="Provider code: USDTERC20, USDTBSC, usd", max_length=20
-                    ),
-                ),
-                (
-                    "min_amount",
-                    models.DecimalField(
-                        blank=True,
-                        decimal_places=8,
-                        help_text="Minimum payment amount",
-                        max_digits=20,
-                        null=True,
-                    ),
-                ),
-                (
-                    "max_amount",
-                    models.DecimalField(
-                        blank=True,
-                        decimal_places=8,
-                        help_text="Maximum payment amount (null = no limit)",
-                        max_digits=20,
-                        null=True,
-                    ),
-                ),
-                ("is_enabled", models.BooleanField(default=True, help_text="Enabled by provider")),
-                (
-                    "available_for_payment",
-                    models.BooleanField(default=True, help_text="Can receive payments"),
-                ),
-                (
-                    "available_for_payout",
-                    models.BooleanField(default=True, help_text="Can send payouts"),
-                ),
-                (
-                    "is_popular",
-                    models.BooleanField(default=False, help_text="Popular/recommended by provider"),
-                ),
-                (
-                    "is_stable",
-                    models.BooleanField(default=False, help_text="Stable coin (USDT, USDC, etc.)"),
-                ),
-                (
-                    "priority",
-                    models.IntegerField(
-                        default=0, help_text="Display priority (higher = shown first)"
-                    ),
-                ),
-                (
-                    "logo_url",
-                    models.URLField(blank=True, help_text="Currency logo/icon URL from provider"),
-                ),
-                (
-                    "metadata",
-                    models.JSONField(
-                        blank=True,
-                        default=dict,
-                        help_text="All provider-specific data: logo_url, smart_contract, wallet_regex, commission_percent, etc.",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "Provider Currency",
-                "verbose_name_plural": "Provider Currencies",
-                "db_table": "payment_provider_currencies",
-                "ordering": ["-priority", "provider_name", "base_currency__code"],
-            },
-        ),
-        migrations.AlterUniqueTogether(
-            name="currencynetwork",
-            unique_together=None,
-        ),
-        migrations.RemoveField(
-            model_name="currencynetwork",
-            name="currency",
-        ),
-        migrations.AlterModelOptions(
-            name="currency",
-            options={
-                "ordering": ["currency_type", "code"],
-                "verbose_name": "Currency",
-                "verbose_name_plural": "Currencies",
-            },
-        ),
-        migrations.RemoveIndex(
-            model_name="currency",
-            name="payment_cur_code_e2a506_idx",
-        ),
-        migrations.RemoveIndex(
-            model_name="currency",
-            name="payment_cur_currenc_6057a9_idx",
-        ),
-        migrations.RemoveIndex(
-            model_name="currency",
-            name="payment_cur_is_acti_8d558f_idx",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="decimal_places",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="is_active",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="min_payment_amount",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="rate_updated_at",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="symbol",
-        ),
-        migrations.RemoveField(
-            model_name="currency",
-            name="usd_rate",
-        ),
-        migrations.AlterField(
-            model_name="currency",
-            name="code",
-            field=models.CharField(
-                help_text="Clean currency code: BTC, USDT, ETH, USD (NO network suffixes)",
-                max_length=10,
-                unique=True,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="currency",
-            name="currency_type",
-            field=models.CharField(
-                choices=[("fiat", "Fiat Currency"), ("crypto", "Cryptocurrency")],
-                help_text="fiat or crypto",
-                max_length=10,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="currency",
-            name="name",
-            field=models.CharField(
-                help_text="Currency name: Bitcoin, Tether USD, Ethereum", max_length=100
-            ),
-        ),
-        migrations.AddField(
-            model_name="providercurrency",
-            name="base_currency",
-            field=models.ForeignKey(
-                help_text="Base currency: BTC, USDT, ETH",
-                on_delete=django.db.models.deletion.CASCADE,
-                related_name="provider_mappings",
-                to="django_cfg_payments.currency",
-            ),
-        ),
-        migrations.AddField(
-            model_name="providercurrency",
-            name="network",
-            field=models.ForeignKey(
-                blank=True,
-                help_text="Network for crypto (null for fiat)",
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                related_name="provider_currencies",
-                to="django_cfg_payments.network",
-            ),
-        ),
-        migrations.DeleteModel(
-            name="CurrencyNetwork",
-        ),
-        migrations.AlterUniqueTogether(
-            name="providercurrency",
-            unique_together={
-                ("provider_name", "base_currency", "network"),
-                ("provider_name", "provider_currency_code"),
-            },
-        ),
-    ]

django_cfg/apps/payments/migrations/0003_add_usd_rate_cache.py

@@ -1,30 +0,0 @@
-# Generated by Django 5.2.6 on 2025-09-25 06:06
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("django_cfg_payments", "0002_network_providercurrency_and_more"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="currency",
-            name="rate_updated_at",
-            field=models.DateTimeField(
-                blank=True, help_text="When the USD rate was last updated", null=True
-            ),
-        ),
-        migrations.AddField(
-            model_name="currency",
-            name="usd_rate",
-            field=models.DecimalField(
-                blank=True,
-                decimal_places=8,
-                help_text="Cached USD exchange rate (1 CURRENCY = X USD)",
-                max_digits=20,
-                null=True,
-            ),
-        ),
-    ]

django_cfg/apps/payments/models/events.py

@@ -1,73 +0,0 @@
-"""
-Event sourcing models for the universal payments system.
-"""
-
-from django.db import models
-from .base import UUIDTimestampedModel
-
-
-class PaymentEvent(UUIDTimestampedModel):
-    """Event sourcing for payment operations - immutable audit trail."""
-    
-    class EventType(models.TextChoices):
-        PAYMENT_CREATED = 'payment_created', 'Payment Created'
-        WEBHOOK_RECEIVED = 'webhook_received', 'Webhook Received'
-        WEBHOOK_PROCESSED = 'webhook_processed', 'Webhook Processed'
-        BALANCE_UPDATED = 'balance_updated', 'Balance Updated'
-        REFUND_PROCESSED = 'refund_processed', 'Refund Processed'
-        STATUS_CHANGED = 'status_changed', 'Status Changed'
-        ERROR_OCCURRED = 'error_occurred', 'Error Occurred'
-    
-    # Event identification
-    payment_id = models.CharField(
-        max_length=255,
-        db_index=True,
-        help_text="Payment identifier"
-    )
-    event_type = models.CharField(
-        max_length=50,
-        choices=EventType.choices,
-        db_index=True,
-        help_text="Type of event"
-    )
-    sequence_number = models.PositiveBigIntegerField(
-        help_text="Sequential number per payment"
-    )
-    
-    # Event data (JSON for flexibility)
-    event_data = models.JSONField(
-        help_text="Event data payload"
-    )
-    
-    # Operational metadata
-    processed_by = models.CharField(
-        max_length=100,
-        help_text="Worker/server that processed this event"
-    )
-    correlation_id = models.CharField(
-        max_length=255,
-        null=True,
-        blank=True,
-        help_text="Correlation ID for tracing"
-    )
-    idempotency_key = models.CharField(
-        max_length=255,
-        unique=True,
-        help_text="Idempotency key to prevent duplicates"
-    )
-    
-    class Meta:
-        db_table = 'payment_events'
-        verbose_name = "Payment Event"
-        verbose_name_plural = "Payment Events"
-        indexes = [
-            models.Index(fields=['payment_id', 'sequence_number']),
-            models.Index(fields=['event_type', 'created_at']),
-            models.Index(fields=['idempotency_key']),
-            models.Index(fields=['correlation_id']),
-            models.Index(fields=['created_at']),
-        ]
-        ordering = ['sequence_number']
-    
-    def __str__(self):
-        return f"Event {self.sequence_number}: {self.event_type} for {self.payment_id}"

django_cfg/apps/payments/serializers/__init__.py

@@ -1,57 +0,0 @@
-"""
-DRF serializers for the universal payments system.
-"""
-
-from .balance import (
-    UserBalanceSerializer, TransactionSerializer, TransactionListSerializer
-)
-from .payments import (
-    UniversalPaymentSerializer, PaymentCreateSerializer, PaymentListSerializer
-)
-from .subscriptions import (
-    SubscriptionSerializer, SubscriptionCreateSerializer, SubscriptionListSerializer,
-    EndpointGroupSerializer
-)
-from .api_keys import (
-    APIKeySerializer, APIKeyCreateSerializer, APIKeyListSerializer
-)
-from .currencies import (
-    CurrencySerializer, NetworkSerializer, ProviderCurrencySerializer, CurrencyListSerializer
-)
-from .tariffs import (
-    TariffSerializer, TariffEndpointGroupSerializer, TariffListSerializer
-)
-
-__all__ = [
-    # Balance
-    'UserBalanceSerializer',
-    'TransactionSerializer',
-    'TransactionListSerializer',
-    
-    # Payments
-    'UniversalPaymentSerializer',
-    'PaymentCreateSerializer',
-    'PaymentListSerializer',
-    
-    # Subscriptions
-    'SubscriptionSerializer',
-    'SubscriptionCreateSerializer',
-    'SubscriptionListSerializer',
-    'EndpointGroupSerializer',
-    
-    # API Keys
-    'APIKeySerializer',
-    'APIKeyCreateSerializer',
-    'APIKeyListSerializer',
-    
-    # Currencies
-    'CurrencySerializer',
-    'NetworkSerializer',
-    'ProviderCurrencySerializer',
-    'CurrencyListSerializer',
-    
-    # Tariffs
-    'TariffSerializer',
-    'TariffEndpointGroupSerializer',
-    'TariffListSerializer',
-]