wagtail-subscriptions 0.1.0__py3-none-any.whl

wagtail_subscriptions/__init__.py

@@ -0,0 +1,8 @@
+"""
+Wagtail Subscriptions - Comprehensive subscription management for Wagtail CMS
+"""
+
+__version__ = "1.0.0"
+__author__ = "Wagtail Subscriptions Team"
+
+default_app_config = "wagtail_subscriptions.apps.WagtailSubscriptionsConfig"

wagtail_subscriptions/admin/__init__.py

@@ -0,0 +1 @@
+# Admin interfaces will be automatically discovered

wagtail_subscriptions/admin/features.py

@@ -0,0 +1,40 @@
+from django.contrib import admin
+
+from ..models import Feature, Module, PlanFeature, UsageRecord
+
+
+@admin.register(Module)
+class ModuleAdmin(admin.ModelAdmin):
+    list_display = ["name", "slug", "is_active", "sort_order"]
+    list_filter = ["is_active"]
+    search_fields = ["name", "slug"]
+    prepopulated_fields = {"slug": ("name",)}
+
+
+@admin.register(Feature)
+class FeatureAdmin(admin.ModelAdmin):
+    list_display = ["name", "module", "feature_type", "is_active", "sort_order"]
+    list_filter = ["module", "feature_type", "is_active"]
+    search_fields = ["name", "slug"]
+    prepopulated_fields = {"slug": ("name",)}
+
+
+@admin.register(PlanFeature)
+class PlanFeatureAdmin(admin.ModelAdmin):
+    list_display = ["plan", "feature", "is_included", "quota_override"]
+    list_filter = ["is_included", "plan", "feature__module"]
+    search_fields = ["plan__name", "feature__name"]
+
+
+@admin.register(UsageRecord)
+class UsageRecordAdmin(admin.ModelAdmin):
+    list_display = [
+        "subscription",
+        "feature",
+        "usage_count",
+        "period_start",
+        "period_end",
+    ]
+    list_filter = ["feature", "period_start"]
+    search_fields = ["subscription__user__email", "feature__name"]
+    readonly_fields = ["created_at", "updated_at"]

wagtail_subscriptions/admin/subscription.py

@@ -0,0 +1,39 @@
+from django.contrib import admin
+
+from ..models import Customer, Invoice, Payment, Subscription
+
+
+@admin.register(Subscription)
+class SubscriptionAdmin(admin.ModelAdmin):
+    list_display = ["user", "plan", "status", "current_period_end", "is_active"]
+    list_filter = ["status", "plan", "created_at"]
+    search_fields = ["user__username", "user__email", "external_id"]
+    readonly_fields = ["external_id", "created_at", "updated_at"]
+
+    def is_active(self, obj):
+        return obj.is_active
+
+    is_active.boolean = True
+
+
+@admin.register(Customer)
+class CustomerAdmin(admin.ModelAdmin):
+    list_display = ["user", "company_name", "billing_email", "country"]
+    search_fields = ["user__username", "user__email", "company_name"]
+    readonly_fields = ["stripe_customer_id", "created_at", "updated_at"]
+
+
+@admin.register(Invoice)
+class InvoiceAdmin(admin.ModelAdmin):
+    list_display = ["invoice_number", "customer", "status", "total", "due_date"]
+    list_filter = ["status", "created_at"]
+    search_fields = ["invoice_number", "customer__user__email"]
+    readonly_fields = ["external_id", "created_at", "updated_at"]
+
+
+@admin.register(Payment)
+class PaymentAdmin(admin.ModelAdmin):
+    list_display = ["external_id", "customer", "amount", "status", "processed_at"]
+    list_filter = ["status", "payment_processor", "created_at"]
+    search_fields = ["external_id", "customer__user__email"]
+    readonly_fields = ["external_id", "created_at", "updated_at"]

wagtail_subscriptions/admin.py

@@ -0,0 +1,104 @@
+from django.contrib import admin
+from wagtail.contrib.modeladmin.options import ModelAdmin
+from wagtail.snippets.models import register_snippet
+
+from .models import (
+    Customer,
+    Feature,
+    Module,
+    PlanFeature,
+    Subscription,
+    SubscriptionPlan,
+    UsageRecord,
+)
+from .models.permissions import SubscriptionGroup, SubscriptionPermission
+
+
+@register_snippet
+class SubscriptionPlanAdmin(ModelAdmin):
+    model = SubscriptionPlan
+    menu_label = "Subscription Plans"
+    menu_icon = "list-ul"
+    list_display = ["name", "price", "billing_period", "is_active", "trial_period_days"]
+    list_filter = ["billing_period", "is_active"]
+    search_fields = ["name", "description"]
+    ordering = ["sort_order", "name"]
+
+
+@register_snippet
+class ModuleAdmin(ModelAdmin):
+    model = Module
+    menu_label = "Modules"
+    menu_icon = "cogs"
+    list_display = ["name", "slug", "is_active", "sort_order"]
+    list_filter = ["is_active"]
+    search_fields = ["name", "description"]
+    ordering = ["sort_order", "name"]
+
+
+@register_snippet
+class FeatureAdmin(ModelAdmin):
+    model = Feature
+    menu_label = "Features"
+    menu_icon = "cog"
+    list_display = ["name", "module", "feature_type", "is_active"]
+    list_filter = ["module", "feature_type", "is_active"]
+    search_fields = ["name", "description"]
+    ordering = ["module", "sort_order", "name"]
+
+
+@admin.register(PlanFeature)
+class PlanFeatureAdmin(admin.ModelAdmin):
+    list_display = ["plan", "feature", "is_included", "quota_override"]
+    list_filter = ["is_included", "plan", "feature__module"]
+    search_fields = ["plan__name", "feature__name"]
+
+
+@admin.register(Subscription)
+class SubscriptionAdmin(admin.ModelAdmin):
+    list_display = [
+        "user",
+        "plan",
+        "status",
+        "current_period_start",
+        "current_period_end",
+    ]
+    list_filter = ["status", "plan", "payment_processor"]
+    search_fields = ["user__username", "user__email", "plan__name"]
+    readonly_fields = ["external_id", "created_at", "updated_at"]
+
+
+@admin.register(Customer)
+class CustomerAdmin(admin.ModelAdmin):
+    list_display = ["user", "company_name", "billing_email", "created_at"]
+    search_fields = ["user__username", "user__email", "company_name", "billing_email"]
+    readonly_fields = ["stripe_customer_id", "created_at", "updated_at"]
+
+
+@admin.register(UsageRecord)
+class UsageRecordAdmin(admin.ModelAdmin):
+    list_display = [
+        "subscription",
+        "feature",
+        "usage_count",
+        "period_start",
+        "period_end",
+    ]
+    list_filter = ["feature", "subscription__plan"]
+    search_fields = ["subscription__user__username", "feature__name"]
+    readonly_fields = ["created_at", "updated_at"]
+
+
+@admin.register(SubscriptionPermission)
+class SubscriptionPermissionAdmin(admin.ModelAdmin):
+    list_display = ["feature", "permission", "created_at"]
+    list_filter = ["feature__module", "permission__content_type"]
+    search_fields = ["feature__name", "permission__name"]
+
+
+@admin.register(SubscriptionGroup)
+class SubscriptionGroupAdmin(admin.ModelAdmin):
+    list_display = ["plan", "name", "created_at"]
+    list_filter = ["plan"]
+    search_fields = ["plan__name", "name"]
+    filter_horizontal = ["permissions"]

wagtail_subscriptions/analytics.py

@@ -0,0 +1,81 @@
+from datetime import timedelta
+from decimal import Decimal
+
+from django.db.models import Avg, Count, Sum
+from django.utils import timezone
+
+from .models import Subscription, UsageRecord
+
+
+class SubscriptionAnalytics:
+    """Analytics for subscription metrics"""
+
+    @staticmethod
+    def get_mrr():
+        """Calculate Monthly Recurring Revenue"""
+        active_subs = Subscription.objects.filter(status__in=["active", "trialing"])
+        monthly_revenue = Decimal("0.00")
+
+        for sub in active_subs:
+            if sub.plan.billing_period == "monthly":
+                monthly_revenue += sub.plan.price
+            elif sub.plan.billing_period == "yearly":
+                monthly_revenue += sub.plan.price / 12
+            elif sub.plan.billing_period == "quarterly":
+                monthly_revenue += sub.plan.price / 3
+
+        return monthly_revenue
+
+    @staticmethod
+    def get_churn_rate(days=30):
+        """Calculate churn rate for the last N days"""
+        end_date = timezone.now()
+        start_date = end_date - timedelta(days=days)
+
+        total_start = Subscription.objects.filter(created_at__lt=start_date).count()
+        churned = Subscription.objects.filter(
+            canceled_at__gte=start_date, canceled_at__lt=end_date
+        ).count()
+
+        return (churned / total_start * 100) if total_start > 0 else 0
+
+    @staticmethod
+    def get_conversion_rate(days=30):
+        """Calculate trial to paid conversion rate"""
+        end_date = timezone.now()
+        start_date = end_date - timedelta(days=days)
+
+        trials = Subscription.objects.filter(
+            created_at__gte=start_date, created_at__lt=end_date, trial_end__isnull=False
+        ).count()
+
+        conversions = Subscription.objects.filter(
+            created_at__gte=start_date,
+            created_at__lt=end_date,
+            trial_end__isnull=False,
+            status="active",
+        ).count()
+
+        return (conversions / trials * 100) if trials > 0 else 0
+
+    @staticmethod
+    def get_feature_usage(feature_slug, days=30):
+        """Get feature usage statistics"""
+        from .models import Feature
+
+        # Validate feature exists to prevent injection
+        try:
+            feature = Feature.objects.get(slug=feature_slug)
+        except Feature.DoesNotExist:
+            return {"total_usage": 0, "avg_usage": 0, "unique_users": 0}
+
+        end_date = timezone.now()
+        start_date = end_date - timedelta(days=days)
+
+        usage = UsageRecord.objects.filter(feature=feature, period_start__gte=start_date).aggregate(
+            total_usage=Sum("usage_count"),
+            avg_usage=Avg("usage_count"),
+            unique_users=Count("subscription__user", distinct=True),
+        )
+
+        return usage

wagtail_subscriptions/apps.py

@@ -0,0 +1,12 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class WagtailSubscriptionsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wagtail_subscriptions"
+    verbose_name = _("Wagtail Subscriptions")
+
+    def ready(self):
+        # Import signal handlers
+        from . import signals  # noqa

wagtail_subscriptions/context_processors.py

@@ -0,0 +1,10 @@
+from .permissions.tenant_manager import TenantSubscriptionManager
+
+
+def subscription_context(request):
+    """Add subscription context to all templates"""
+    return {
+        "subscription_info": TenantSubscriptionManager.get_subscriber_info(request),
+        "is_multi_tenant": TenantSubscriptionManager.is_multi_tenant(),
+        "current_plan": TenantSubscriptionManager.get_active_plan(request),
+    }

wagtail_subscriptions/forms.py

@@ -0,0 +1,76 @@
+from django import forms
+
+
+class PaymentProcessorConfigForm(forms.Form):
+    processor = forms.ChoiceField(
+        choices=[
+            ("stripe", "Stripe"),
+            ("paddle", "Paddle"),
+            ("paypal", "PayPal"),
+        ],
+        widget=forms.Select(attrs={"class": "form-control"}),
+    )
+
+    # Stripe fields
+    stripe_public_key = forms.CharField(
+        required=False,
+        widget=forms.TextInput(attrs={"class": "form-control", "placeholder": "pk_test_..."}),
+    )
+    stripe_secret_key = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(attrs={"class": "form-control", "placeholder": "sk_test_..."}),
+    )
+    stripe_webhook_secret = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(attrs={"class": "form-control", "placeholder": "whsec_..."}),
+    )
+
+    # Paddle fields
+    paddle_vendor_id = forms.CharField(
+        required=False,
+        widget=forms.TextInput(attrs={"class": "form-control", "placeholder": "12345"}),
+    )
+    paddle_vendor_auth_code = forms.CharField(
+        required=False, widget=forms.PasswordInput(attrs={"class": "form-control"})
+    )
+    paddle_public_key = forms.CharField(
+        required=False,
+        widget=forms.Textarea(attrs={"class": "form-control", "rows": 4}),
+    )
+
+    # PayPal fields
+    paypal_client_id = forms.CharField(
+        required=False, widget=forms.TextInput(attrs={"class": "form-control"})
+    )
+    paypal_client_secret = forms.CharField(
+        required=False, widget=forms.PasswordInput(attrs={"class": "form-control"})
+    )
+    paypal_mode = forms.ChoiceField(
+        choices=[("sandbox", "Sandbox"), ("live", "Live")],
+        required=False,
+        widget=forms.Select(attrs={"class": "form-control"}),
+    )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        processor = cleaned_data.get("processor")
+
+        if processor == "stripe":
+            if not cleaned_data.get("stripe_secret_key"):
+                raise forms.ValidationError("Stripe secret key is required for Stripe processor")
+        elif processor == "paypal":
+            if not cleaned_data.get("paypal_client_id") or not cleaned_data.get(
+                "paypal_client_secret"
+            ):
+                raise forms.ValidationError(
+                    "PayPal client ID and secret are required for PayPal processor"
+                )
+        elif processor == "paddle":
+            if not cleaned_data.get("paddle_vendor_id") or not cleaned_data.get(
+                "paddle_vendor_auth_code"
+            ):
+                raise forms.ValidationError(
+                    "Paddle vendor ID and auth code are required for Paddle processor"
+                )
+
+        return cleaned_data

wagtail_subscriptions/management/__init__.py

@@ -0,0 +1 @@
+# Management commands package

wagtail_subscriptions/management/commands/__init__.py

@@ -0,0 +1 @@
+# Management commands

wagtail_subscriptions/management/commands/check_expired_subscriptions.py

@@ -0,0 +1,41 @@
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+from wagtail_subscriptions.models import Subscription
+
+
+class Command(BaseCommand):
+    help = "Check for expired subscriptions and update their status"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be updated without making changes",
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options["dry_run"]
+        now = timezone.now()
+
+        # Find expired trials
+        expired_trials = Subscription.objects.filter(status="trialing", trial_end__lt=now)
+
+        # Find expired subscriptions
+        expired_subscriptions = Subscription.objects.filter(
+            status="active", current_period_end__lt=now
+        )
+
+        if dry_run:
+            self.stdout.write(f"Would update {expired_trials.count()} expired trials")
+            self.stdout.write(f"Would update {expired_subscriptions.count()} expired subscriptions")
+        else:
+            # Update expired trials
+            updated_trials = expired_trials.update(status="past_due")
+            self.stdout.write(f"Updated {updated_trials} expired trials")
+
+            # Update expired subscriptions
+            updated_subs = expired_subscriptions.update(status="past_due")
+            self.stdout.write(f"Updated {updated_subs} expired subscriptions")
+
+            self.stdout.write(self.style.SUCCESS("Successfully processed expired subscriptions"))

wagtail_subscriptions/management/commands/create_sample_plans.py

@@ -0,0 +1,247 @@
+from django.core.management.base import BaseCommand
+
+from wagtail_subscriptions.models import Feature, Module, PlanFeature, SubscriptionPlan
+
+
+class Command(BaseCommand):
+    help = "Create sample subscription plans and features"
+
+    def handle(self, *args, **options):
+        # Create modules based on cashsheet structure
+        accounting_module, _ = Module.objects.get_or_create(
+            slug="accounting",
+            defaults={
+                "name": "Accounting",
+                "description": "Core accounting and bookkeeping features",
+                "icon": "calculator",
+                "is_active": True,
+                "sort_order": 1,
+            },
+        )
+
+        reporting_module, _ = Module.objects.get_or_create(
+            slug="reporting",
+            defaults={
+                "name": "Reporting & Analytics",
+                "description": "Financial reports and business analytics",
+                "icon": "chart-bar",
+                "is_active": True,
+                "sort_order": 2,
+            },
+        )
+
+        collaboration_module, _ = Module.objects.get_or_create(
+            slug="collaboration",
+            defaults={
+                "name": "Team Collaboration",
+                "description": "Multi-user access and team features",
+                "icon": "users",
+                "is_active": True,
+                "sort_order": 3,
+            },
+        )
+
+        # Create features based on cashsheet functionality
+        features_data = [
+            # Accounting Module Features
+            {
+                "module": accounting_module,
+                "name": "Chart of Accounts",
+                "slug": "chart-of-accounts",
+                "feature_type": "binary",
+                "description": "Create and manage chart of accounts",
+            },
+            {
+                "module": accounting_module,
+                "name": "Journal Entries",
+                "slug": "journal-entries",
+                "feature_type": "quota",
+                "description": "Monthly journal entries limit",
+                "default_quota": 100,
+                "quota_unit": "entries/month",
+            },
+            {
+                "module": accounting_module,
+                "name": "Bank Reconciliation",
+                "slug": "bank-reconciliation",
+                "feature_type": "binary",
+                "description": "Automated bank reconciliation",
+            },
+            {
+                "module": accounting_module,
+                "name": "Invoicing",
+                "slug": "invoicing",
+                "feature_type": "quota",
+                "description": "Create and send invoices",
+                "default_quota": 50,
+                "quota_unit": "invoices/month",
+            },
+            # Reporting Module Features
+            {
+                "module": reporting_module,
+                "name": "Financial Statements",
+                "slug": "financial-statements",
+                "feature_type": "binary",
+                "description": "Balance Sheet, Income Statement, Cash Flow",
+            },
+            {
+                "module": reporting_module,
+                "name": "Custom Reports",
+                "slug": "custom-reports",
+                "feature_type": "quota",
+                "description": "Create custom financial reports",
+                "default_quota": 5,
+                "quota_unit": "reports",
+            },
+            {
+                "module": reporting_module,
+                "name": "Advanced Analytics",
+                "slug": "advanced-analytics",
+                "feature_type": "binary",
+                "description": "Business intelligence and forecasting",
+            },
+            # Collaboration Module Features
+            {
+                "module": collaboration_module,
+                "name": "Team Members",
+                "slug": "team-members",
+                "feature_type": "quota",
+                "description": "Number of team members",
+                "default_quota": 1,
+                "quota_unit": "users",
+            },
+            {
+                "module": collaboration_module,
+                "name": "Organizations",
+                "slug": "organizations",
+                "feature_type": "quota",
+                "description": "Number of organizations/entities",
+                "default_quota": 1,
+                "quota_unit": "organizations",
+            },
+            {
+                "module": collaboration_module,
+                "name": "Priority Support",
+                "slug": "priority-support",
+                "feature_type": "binary",
+                "description": "24/7 priority customer support",
+            },
+        ]
+
+        features = {}
+        for feature_data in features_data:
+            feature, _ = Feature.objects.get_or_create(
+                slug=feature_data["slug"],
+                module=feature_data["module"],
+                defaults=feature_data,
+            )
+            features[feature_data["slug"]] = feature
+
+        # Create plans based on cashsheet pricing structure
+        plans_data = [
+            {
+                "name": "Starter",
+                "slug": "starter",
+                "price": 0.00,
+                "billing_period": "monthly",
+                "trial_period_days": 0,
+                "description": "Perfect for freelancers and small businesses getting started",
+                "sort_order": 1,
+            },
+            {
+                "name": "Professional",
+                "slug": "professional",
+                "price": 29.00,
+                "billing_period": "monthly",
+                "trial_period_days": 14,
+                "description": "For growing businesses with advanced accounting needs",
+                "sort_order": 2,
+            },
+            {
+                "name": "Premium",
+                "slug": "premium",
+                "price": 79.00,
+                "billing_period": "monthly",
+                "trial_period_days": 30,
+                "description": "For large organizations with unlimited access",
+                "sort_order": 3,
+            },
+        ]
+
+        for plan_data in plans_data:
+            plan, created = SubscriptionPlan.objects.get_or_create(
+                slug=plan_data["slug"], defaults=plan_data
+            )
+
+            if created:
+                self.stdout.write(f"Created plan: {plan.name}")
+
+                # Associate features with plans based on cashsheet structure
+                if plan.slug == "starter":
+                    # Starter plan - basic features with limits
+                    starter_features = {
+                        "chart-of-accounts": {"quota": None},
+                        "journal-entries": {"quota": 50},
+                        "invoicing": {"quota": 10},
+                        "financial-statements": {"quota": None},
+                        "team-members": {"quota": 1},
+                        "organizations": {"quota": 1},
+                    }
+                    for feature_slug, config in starter_features.items():
+                        PlanFeature.objects.get_or_create(
+                            plan=plan,
+                            feature=features[feature_slug],
+                            defaults={
+                                "is_included": True,
+                                "quota_override": config["quota"],
+                            },
+                        )
+
+                elif plan.slug == "professional":
+                    # Professional plan - expanded features
+                    pro_features = {
+                        "chart-of-accounts": {"quota": None},
+                        "journal-entries": {"quota": 500},
+                        "bank-reconciliation": {"quota": None},
+                        "invoicing": {"quota": 100},
+                        "financial-statements": {"quota": None},
+                        "custom-reports": {"quota": 10},
+                        "advanced-analytics": {"quota": None},
+                        "team-members": {"quota": 5},
+                        "organizations": {"quota": 3},
+                    }
+                    for feature_slug, config in pro_features.items():
+                        PlanFeature.objects.get_or_create(
+                            plan=plan,
+                            feature=features[feature_slug],
+                            defaults={
+                                "is_included": True,
+                                "quota_override": config["quota"],
+                            },
+                        )
+
+                elif plan.slug == "premium":
+                    # Premium plan - unlimited access
+                    premium_features = {
+                        "chart-of-accounts": {"quota": None},
+                        "journal-entries": {"quota": 9999},
+                        "bank-reconciliation": {"quota": None},
+                        "invoicing": {"quota": 9999},
+                        "financial-statements": {"quota": None},
+                        "custom-reports": {"quota": 9999},
+                        "advanced-analytics": {"quota": None},
+                        "team-members": {"quota": 9999},
+                        "organizations": {"quota": 9999},
+                        "priority-support": {"quota": None},
+                    }
+                    for feature_slug, config in premium_features.items():
+                        PlanFeature.objects.get_or_create(
+                            plan=plan,
+                            feature=features[feature_slug],
+                            defaults={
+                                "is_included": True,
+                                "quota_override": config["quota"],
+                            },
+                        )
+
+        self.stdout.write(self.style.SUCCESS("Successfully created sample plans and features"))