university-subscriptions 0.1.0__tar.gz

university_subscriptions-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.nox/
+.tox/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+# Django
+*.sqlite3
+# Local user uploads (never the university.media source package).
+/media/
+/private-media/
+example_project/media/
+example_project/private-media/
+staticfiles/
+
+# Secrets — never commit
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+# Editors / OS
+.idea/
+.vscode/
+.DS_Store
+Thumbs.db
+
+# GistLoop is a separate project with its own repository.
+/GistLoop/

university_subscriptions-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

university_subscriptions-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: university-subscriptions
+Version: 0.1.0
+Summary: University Subscriptions: Premium plans, paid periods and entitlements other modules can check.
+Author-email: Ifeanyi Stanley <nnamaniifeanyi10@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: university-core<0.2,>=0.1.1
+Provides-Extra: test
+Requires-Dist: drf-spectacular>=0.27; extra == 'test'
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest-django>=4.8; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# university-subscriptions
+
+Premium plans, paid periods and entitlements other modules can check.
+
+An optional **level-two** module of the University platform.
+
+## Installation
+
+```bash
+pip install university-subscriptions university-payments
+```
+
+```python
+INSTALLED_APPS = [
+    # ...
+    *CORE_APPS,
+    "university.payments",
+    "university.subscriptions",
+]
+```
+
+Run `python manage.py migrate`. The API is mounted under `/api/v1/subscriptions/`.
+
+## How it works
+
+1. `GET plans/` lists the plans, prices and what each includes.
+2. `POST me/` with `{plan, interval, currency}` chooses a plan. The response's `payment_due`
+   is passed to `POST /api/v1/payments/checkout/` (purpose `subscriptions.period`).
+3. When the payment succeeds the subscription becomes `active` for one interval.
+4. Renewals are paid by the member (no stored cards) from `RENEWAL_WINDOW_DAYS` before the
+   period ends. A reminder goes out `REMINDER_DAYS` before, and entitlements continue for
+   `GRACE_DAYS` after an unpaid period ends, then the subscription expires.
+5. `POST me/cancel/` stops renewing; the plan lasts until the paid period ends.
+
+Run the `university.subscriptions.sweep` task (or call `services.sweep()`) every hour.
+
+## Entitlements
+
+Plans grant entitlement keys. Any module can check them through Core, without depending on
+this package:
+
+```python
+from university.core.entitlements import has_entitlement
+
+if has_entitlement(request.user, "creator.analytics_pro"):
+    ...
+```
+
+`premium.ad_free` hides adverts in university-promotions; `premium.badge` adds `premium: true`
+to public profiles.
+
+## Configuration
+
+```python
+UNIVERSITY = {
+    "SUBSCRIPTIONS": {
+        "PLANS": {
+            "plus": {
+                "name": "Plus",
+                "description": "No adverts and a profile badge.",
+                "prices": {"month": {"NGN": 150000}, "year": {"NGN": 1500000}},
+                "entitlements": ["premium.ad_free", "premium.badge"],
+            },
+        },
+        "GRACE_DAYS": 3,
+    },
+}
+```
+
+A double payment, or a payment for the wrong amount, is refused and refunded by
+university-payments. A refunded period is taken back off the subscription.

university_subscriptions-0.1.0/README.md

@@ -0,0 +1,71 @@
+# university-subscriptions
+
+Premium plans, paid periods and entitlements other modules can check.
+
+An optional **level-two** module of the University platform.
+
+## Installation
+
+```bash
+pip install university-subscriptions university-payments
+```
+
+```python
+INSTALLED_APPS = [
+    # ...
+    *CORE_APPS,
+    "university.payments",
+    "university.subscriptions",
+]
+```
+
+Run `python manage.py migrate`. The API is mounted under `/api/v1/subscriptions/`.
+
+## How it works
+
+1. `GET plans/` lists the plans, prices and what each includes.
+2. `POST me/` with `{plan, interval, currency}` chooses a plan. The response's `payment_due`
+   is passed to `POST /api/v1/payments/checkout/` (purpose `subscriptions.period`).
+3. When the payment succeeds the subscription becomes `active` for one interval.
+4. Renewals are paid by the member (no stored cards) from `RENEWAL_WINDOW_DAYS` before the
+   period ends. A reminder goes out `REMINDER_DAYS` before, and entitlements continue for
+   `GRACE_DAYS` after an unpaid period ends, then the subscription expires.
+5. `POST me/cancel/` stops renewing; the plan lasts until the paid period ends.
+
+Run the `university.subscriptions.sweep` task (or call `services.sweep()`) every hour.
+
+## Entitlements
+
+Plans grant entitlement keys. Any module can check them through Core, without depending on
+this package:
+
+```python
+from university.core.entitlements import has_entitlement
+
+if has_entitlement(request.user, "creator.analytics_pro"):
+    ...
+```
+
+`premium.ad_free` hides adverts in university-promotions; `premium.badge` adds `premium: true`
+to public profiles.
+
+## Configuration
+
+```python
+UNIVERSITY = {
+    "SUBSCRIPTIONS": {
+        "PLANS": {
+            "plus": {
+                "name": "Plus",
+                "description": "No adverts and a profile badge.",
+                "prices": {"month": {"NGN": 150000}, "year": {"NGN": 1500000}},
+                "entitlements": ["premium.ad_free", "premium.badge"],
+            },
+        },
+        "GRACE_DAYS": 3,
+    },
+}
+```
+
+A double payment, or a payment for the wrong amount, is refused and refunded by
+university-payments. A refunded period is taken back off the subscription.

university_subscriptions-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "university-subscriptions"
+dynamic = ["version"]
+description = "University Subscriptions: Premium plans, paid periods and entitlements other modules can check."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Ifeanyi Stanley", email = "nnamaniifeanyi10@gmail.com" }]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Framework :: Django :: 6.1",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+# Level-two modules depend on Core only. Depend on another module only when
+# unavoidable, and never in a cycle.
+dependencies = ["university-core>=0.1.1,<0.2"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-django>=4.8", "pytest-cov>=5", "drf-spectacular>=0.27"]
+
+[tool.hatch.version]
+path = "src/university/subscriptions/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/university"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+pythonpath = ["."]
+testpaths = ["tests"]
+addopts = "-ra --strict-markers"
+markers = ["security: security regression tests"]

university_subscriptions-0.1.0/src/university/subscriptions/__init__.py

@@ -0,0 +1,3 @@
+"""University Subscriptions: premium plans, paid periods and entitlements."""
+
+__version__ = "0.1.0"

university_subscriptions-0.1.0/src/university/subscriptions/admin.py

@@ -0,0 +1,19 @@
+from django.contrib import admin
+
+from university.subscriptions.models import Period, Subscription
+
+
+class PeriodInline(admin.TabularInline):
+    model = Period
+    extra = 0
+    can_delete = False
+    readonly_fields = ("starts_at", "ends_at", "amount_minor", "currency", "payment_reference")
+
+
+@admin.register(Subscription)
+class SubscriptionAdmin(admin.ModelAdmin):
+    list_display = ("user", "plan", "interval", "status", "current_period_end", "cancel_at_period_end")
+    list_filter = ("plan", "status", "interval")
+    search_fields = ("user__handle", "user__email")
+    readonly_fields = ("user", "current_period_start", "current_period_end", "reminded_for")
+    inlines = [PeriodInline]

university_subscriptions-0.1.0/src/university/subscriptions/api/v1/serializers.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rest_framework import serializers
+
+from university.core.api.schema import extend_schema_field
+from university.subscriptions.conf import plans, subscriptions_settings
+from university.subscriptions.models import Interval, Period, Subscription
+
+
+class SubscriptionEntitlementSerializer(serializers.Serializer):
+    key = serializers.CharField()
+    label = serializers.CharField()
+
+
+class SubscriptionPriceSerializer(serializers.Serializer):
+    interval = serializers.ChoiceField(choices=Interval.choices)
+    currency = serializers.CharField()
+    amount_minor = serializers.IntegerField()
+
+
+class SubscriptionPlanSerializer(serializers.Serializer):
+    key = serializers.CharField()
+    name = serializers.CharField()
+    description = serializers.CharField()
+    prices = SubscriptionPriceSerializer(many=True)
+    entitlements = SubscriptionEntitlementSerializer(many=True)
+
+
+def plan_data(key: str, plan: dict[str, Any]) -> dict[str, Any]:
+    labels = subscriptions_settings.get("ENTITLEMENT_LABELS") or {}
+    return {
+        "key": key,
+        "name": plan.get("name", key),
+        "description": plan.get("description", ""),
+        "prices": [
+            {"interval": interval, "currency": currency, "amount_minor": int(amount)}
+            for interval, by_currency in (plan.get("prices") or {}).items()
+            for currency, amount in by_currency.items()
+        ],
+        "entitlements": [{"key": k, "label": labels.get(k, k)} for k in plan.get("entitlements", [])],
+    }
+
+
+class SubscriptionPeriodSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Period
+        fields = ("starts_at", "ends_at", "amount_minor", "currency", "payment_reference")
+        read_only_fields = fields
+
+
+class SubscriptionPaymentHintSerializer(serializers.Serializer):
+    """Pass to POST /payments/checkout/ to pay what's due."""
+
+    purpose = serializers.CharField()
+    object_id = serializers.CharField()
+    amount_minor = serializers.IntegerField()
+    currency = serializers.CharField()
+
+
+class SubscriptionSerializer(serializers.ModelSerializer):
+    plan_name = serializers.SerializerMethodField()
+    payment_due = serializers.SerializerMethodField()
+    periods = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Subscription
+        fields = (
+            "id", "plan", "plan_name", "interval", "currency", "status", "current_period_start", "current_period_end",
+            "cancel_at_period_end", "payment_due", "periods", "created_at",
+        )  # fmt: skip
+        read_only_fields = fields
+
+    def get_plan_name(self, obj: Subscription) -> str:
+        return str(plans().get(obj.plan, {}).get("name", obj.plan))
+
+    @extend_schema_field(SubscriptionPaymentHintSerializer(allow_null=True))
+    def get_payment_due(self, obj: Subscription) -> dict[str, Any] | None:
+        from university.subscriptions.services import PURPOSE, amount_due
+
+        due = amount_due(obj)
+        if due is None:
+            return None
+        return {"purpose": PURPOSE, "object_id": str(obj.pk), "amount_minor": due, "currency": obj.currency}
+
+    @extend_schema_field(SubscriptionPeriodSerializer(many=True))
+    def get_periods(self, obj: Subscription) -> list[dict[str, Any]]:
+        return SubscriptionPeriodSerializer(obj.periods.all()[:12], many=True).data
+
+
+class MySubscriptionSerializer(serializers.Serializer):
+    subscription = SubscriptionSerializer(allow_null=True)
+    entitlements = serializers.ListField(child=serializers.CharField())
+
+
+class SubscribeSerializer(serializers.Serializer):
+    plan = serializers.CharField(max_length=32)
+    interval = serializers.ChoiceField(choices=Interval.choices)
+    currency = serializers.CharField(max_length=3, default="NGN")
+
+
+class CancelSerializer(serializers.Serializer):
+    cancel = serializers.BooleanField(default=True, help_text="False to keep renewing (undo a cancellation).")

university_subscriptions-0.1.0/src/university/subscriptions/api/v1/urls.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from django.urls import path
+
+from university.subscriptions.api.v1 import views
+
+app_name = "subscriptions"
+
+urlpatterns = [
+    path("plans/", views.PlanListView.as_view(), name="plan-list"),
+    path("me/", views.MySubscriptionView.as_view(), name="me"),
+    path("me/cancel/", views.CancelView.as_view(), name="me-cancel"),
+]

university_subscriptions-0.1.0/src/university/subscriptions/api/v1/views.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from rest_framework import permissions, status
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from university.core.api.schema import extend_schema
+from university.core.entitlements import entitlements
+from university.subscriptions import services
+from university.subscriptions.api.v1 import serializers as s
+from university.subscriptions.conf import plans
+
+
+class PlanListView(APIView):
+    permission_classes = [permissions.AllowAny]
+
+    @extend_schema(responses=s.SubscriptionPlanSerializer(many=True))
+    def get(self, request: Request) -> Response:
+        return Response([s.plan_data(key, plan) for key, plan in plans().items()])
+
+
+class MySubscriptionView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    def _body(self, request: Request) -> dict:
+        sub = services.current(request.user)
+        return {
+            "subscription": s.SubscriptionSerializer(sub).data if sub else None,
+            "entitlements": sorted(entitlements(request.user)),
+        }
+
+    @extend_schema(responses=s.MySubscriptionSerializer)
+    def get(self, request: Request) -> Response:
+        return Response(self._body(request))
+
+    @extend_schema(
+        request=s.SubscribeSerializer,
+        responses={201: s.SubscriptionSerializer},
+        description="Choose a plan. Then pay `payment_due` through POST /payments/checkout/.",
+    )
+    def post(self, request: Request) -> Response:
+        serializer = s.SubscribeSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        sub = services.subscribe(user=request.user, **serializer.validated_data)
+        return Response(s.SubscriptionSerializer(sub).data, status=status.HTTP_201_CREATED)
+
+    @extend_schema(responses={204: None}, description="Drop a subscription that hasn't been paid for yet.")
+    def delete(self, request: Request) -> Response:
+        services.abandon(user=request.user)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class CancelView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
+    @extend_schema(
+        request=s.CancelSerializer,
+        responses=s.SubscriptionSerializer,
+        description="Stop renewing: the plan stays until the paid period ends. Send cancel=false to undo.",
+    )
+    def post(self, request: Request) -> Response:
+        serializer = s.CancelSerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        sub = services.set_cancel_at_period_end(user=request.user, cancel=serializer.validated_data["cancel"])
+        return Response(s.SubscriptionSerializer(sub).data)

university_subscriptions-0.1.0/src/university/subscriptions/apps.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.utils.translation import gettext_lazy as _
+
+from university.core.hooks import Hook, HookRegistry
+from university.core.modules import UniversityAppConfig
+from university.subscriptions import __version__
+
+
+class SubscriptionsConfig(UniversityAppConfig):
+    name = "university.subscriptions"
+    label = "university_subscriptions"
+    verbose_name = _("University Subscriptions")
+    module_name = "subscriptions"
+    module_version = __version__
+    module_requires = ("core", "users", "audit")
+    settings_namespace = "SUBSCRIPTIONS"
+    api_prefix = "subscriptions/"
+    api_urlconfs = {"v1": "university.subscriptions.api.v1.urls"}
+
+    def get_payable_adapters(self) -> list[Any]:
+        from university.subscriptions.payables import PeriodPayable
+
+        return [PeriodPayable()]
+
+    def register_hooks(self, hooks: HookRegistry) -> None:
+        from university.subscriptions import integrations, services
+
+        hooks.register(Hook.USER_ENTITLEMENTS, services.user_entitlements)
+        hooks.register(Hook.USER_PUBLIC_PROFILE, integrations.public_profile)
+        hooks.register(Hook.USER_EXPORT_DATA, integrations.export_data)
+        hooks.register(Hook.USER_PURGE, integrations.purge)

university_subscriptions-0.1.0/src/university/subscriptions/conf.py

@@ -0,0 +1,58 @@
+"""Settings for subscriptions (``UNIVERSITY["SUBSCRIPTIONS"]``)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from university.core.conf import ModuleSettings
+
+DEFAULTS: dict[str, Any] = {
+    # Plan key -> definition. Prices are per interval, per currency, in minor units. A plan's
+    # entitlements are keys other modules check with university.core.entitlements.
+    "PLANS": {
+        "plus": {
+            "name": "Plus",
+            "description": "No adverts, a profile badge and more control over your inbox.",
+            "prices": {"month": {"NGN": 150000, "USD": 299}, "year": {"NGN": 1500000, "USD": 2999}},
+            "entitlements": ["premium.ad_free", "premium.badge", "premium.inbox_filters"],
+        },
+        "creator_pro": {
+            "name": "Creator Pro",
+            "description": "Everything in Plus, with deeper analytics and priority sponsorship placement.",
+            "prices": {"month": {"NGN": 500000, "USD": 999}, "year": {"NGN": 5000000, "USD": 9999}},
+            "entitlements": [
+                "premium.ad_free",
+                "premium.badge",
+                "premium.inbox_filters",
+                "creator.analytics_pro",
+                "creator.priority_listing",
+            ],
+        },
+    },
+    # Human labels for entitlement keys, shown on the plans page.
+    "ENTITLEMENT_LABELS": {
+        "premium.ad_free": "No adverts",
+        "premium.badge": "Premium badge on your profile",
+        "premium.inbox_filters": "Anonymous inbox filters",
+        "creator.analytics_pro": "Advanced creator analytics",
+        "creator.priority_listing": "Priority in the creator directory",
+    },
+    "INTERVAL_DAYS": {"month": 30, "year": 365},
+    # A renewal can be paid this many days before the period ends.
+    "RENEWAL_WINDOW_DAYS": 7,
+    # Reminder sent this many days before the period ends.
+    "REMINDER_DAYS": 3,
+    # After a period ends unpaid, entitlements continue this long before the subscription expires.
+    "GRACE_DAYS": 3,
+}
+
+subscriptions_settings = ModuleSettings("SUBSCRIPTIONS", DEFAULTS)
+
+
+def plans() -> dict[str, dict[str, Any]]:
+    return dict(subscriptions_settings.get("PLANS") or {})
+
+
+def price(plan: str, interval: str, currency: str) -> int | None:
+    value = (plans().get(plan, {}).get("prices", {}).get(interval) or {}).get(currency)
+    return int(value) if value else None

university_subscriptions-0.1.0/src/university/subscriptions/events.py

@@ -0,0 +1,10 @@
+"""Events published by subscriptions (ids only)."""
+
+#: {"subscription_id", "user_id", "plan"}: the first period was paid.
+SUBSCRIPTION_ACTIVATED = "subscriptions.subscription.activated"
+#: {"subscription_id", "user_id", "plan"}: a further period was paid.
+SUBSCRIPTION_RENEWED = "subscriptions.subscription.renewed"
+#: {"subscription_id", "user_id", "plan"}: the period ends soon and isn't paid yet.
+SUBSCRIPTION_RENEWAL_DUE = "subscriptions.subscription.renewal_due"
+#: {"subscription_id", "user_id", "plan"}: entitlements ended.
+SUBSCRIPTION_EXPIRED = "subscriptions.subscription.expired"

university_subscriptions-0.1.0/src/university/subscriptions/integrations.py

@@ -0,0 +1,49 @@
+"""Profile badge, data export, purge and the scheduled sweep for subscriptions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from university.core.entitlements import has_entitlement
+from university.core.tasks import task
+from university.subscriptions.models import Subscription
+
+
+def public_profile(target: Any, viewer: Any) -> dict[str, Any]:
+    # Only the badge is public; plans and payments never are.
+    return {"premium": has_entitlement(target, "premium.badge")}
+
+
+def export_data(user: Any) -> dict[str, Any]:
+    return {
+        "subscriptions": [
+            {
+                "id": s.pk,
+                "plan": s.plan,
+                "interval": s.interval,
+                "status": s.status,
+                "periods": [
+                    {
+                        "starts_at": p.starts_at,
+                        "ends_at": p.ends_at,
+                        "amount_minor": p.amount_minor,
+                        "currency": p.currency,
+                    }
+                    for p in s.periods.all()
+                ],
+            }
+            for s in Subscription.objects.filter(user=user).prefetch_related("periods")
+        ]
+    }
+
+
+def purge(user_id: Any) -> None:
+    # Payment records live (anonymised) in university-payments' ledger; the plan history goes.
+    Subscription.objects.filter(user_id=user_id).delete()
+
+
+@task(name="university.subscriptions.sweep")
+def sweep() -> dict[str, int]:
+    from university.subscriptions.services import sweep as run
+
+    return run()

university_subscriptions-0.1.0/src/university/subscriptions/migrations/0001_initial.py

@@ -0,0 +1,61 @@
+# Generated by Django 6.1.2 on 2026-10-28 16:41
+
+import django.db.models.deletion
+import django.utils.timezone
+import university.core.ids
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Subscription',
+            fields=[
+                ('id', models.UUIDField(default=university.core.ids.new_uuid, editable=False, primary_key=True, serialize=False)),
+                ('created_at', models.DateTimeField(default=django.utils.timezone.now, editable=False, verbose_name='created at')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='updated at')),
+                ('plan', models.CharField(max_length=32)),
+                ('interval', models.CharField(choices=[('month', 'Monthly'), ('year', 'Yearly')], max_length=8)),
+                ('currency', models.CharField(max_length=3)),
+                ('status', models.CharField(choices=[('pending_payment', 'Awaiting first payment'), ('active', 'Active'), ('past_due', 'Renewal due (grace period)'), ('expired', 'Expired'), ('abandoned', 'Never paid')], default='pending_payment', max_length=16)),
+                ('current_period_start', models.DateTimeField(blank=True, null=True)),
+                ('current_period_end', models.DateTimeField(blank=True, null=True)),
+                ('cancel_at_period_end', models.BooleanField(default=False)),
+                ('reminded_for', models.DateTimeField(blank=True, null=True)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='subscriptions', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Period',
+            fields=[
+                ('id', models.UUIDField(default=university.core.ids.new_uuid, editable=False, primary_key=True, serialize=False)),
+                ('created_at', models.DateTimeField(default=django.utils.timezone.now, editable=False, verbose_name='created at')),
+                ('updated_at', models.DateTimeField(auto_now=True, verbose_name='updated at')),
+                ('starts_at', models.DateTimeField()),
+                ('ends_at', models.DateTimeField()),
+                ('amount_minor', models.PositiveBigIntegerField()),
+                ('currency', models.CharField(max_length=3)),
+                ('payment_reference', models.CharField(max_length=64, unique=True)),
+                ('subscription', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='periods', to='university_subscriptions.subscription')),
+            ],
+            options={
+                'ordering': ('-starts_at',),
+            },
+        ),
+        migrations.AddIndex(
+            model_name='subscription',
+            index=models.Index(fields=['status', 'current_period_end'], name='univ_subs_status_end'),
+        ),
+        migrations.AddConstraint(
+            model_name='subscription',
+            constraint=models.UniqueConstraint(condition=models.Q(('status__in', ('pending_payment', 'active', 'past_due'))), fields=('user',), name='univ_subs_one_live_per_user'),
+        ),
+    ]

university_subscriptions-0.1.0/src/university/subscriptions/models.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from django.conf import settings
+from django.db import models
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+
+from university.core.models import BaseModel
+
+
+class Interval(models.TextChoices):
+    MONTH = "month", _("Monthly")
+    YEAR = "year", _("Yearly")
+
+
+class SubscriptionStatus(models.TextChoices):
+    PENDING_PAYMENT = "pending_payment", _("Awaiting first payment")
+    ACTIVE = "active", _("Active")
+    PAST_DUE = "past_due", _("Renewal due (grace period)")
+    EXPIRED = "expired", _("Expired")
+    ABANDONED = "abandoned", _("Never paid")
+
+
+LIVE = (SubscriptionStatus.PENDING_PAYMENT, SubscriptionStatus.ACTIVE, SubscriptionStatus.PAST_DUE)
+ENTITLED = (SubscriptionStatus.ACTIVE, SubscriptionStatus.PAST_DUE)
+
+
+class Subscription(BaseModel):
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="subscriptions")
+    plan = models.CharField(max_length=32)
+    interval = models.CharField(max_length=8, choices=Interval.choices)
+    currency = models.CharField(max_length=3)
+    status = models.CharField(
+        max_length=16, choices=SubscriptionStatus.choices, default=SubscriptionStatus.PENDING_PAYMENT
+    )
+    current_period_start = models.DateTimeField(null=True, blank=True)
+    current_period_end = models.DateTimeField(null=True, blank=True)
+    #: The member doesn't intend to renew: no reminders; it simply ends.
+    cancel_at_period_end = models.BooleanField(default=False)
+    #: The period end a reminder was last sent for (one reminder per period).
+    reminded_for = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(fields=["user"], condition=Q(status__in=LIVE), name="univ_subs_one_live_per_user"),
+        ]
+        indexes = [models.Index(fields=["status", "current_period_end"], name="univ_subs_status_end")]
+
+    def __str__(self) -> str:
+        return f"{self.plan} ({self.status})"
+
+
+class Period(BaseModel):
+    """One paid period: the receipt trail for a subscription."""
+
+    subscription = models.ForeignKey(Subscription, on_delete=models.CASCADE, related_name="periods")
+    starts_at = models.DateTimeField()
+    ends_at = models.DateTimeField()
+    amount_minor = models.PositiveBigIntegerField()
+    currency = models.CharField(max_length=3)
+    payment_reference = models.CharField(max_length=64, unique=True)
+
+    class Meta:
+        ordering = ("-starts_at",)

university_subscriptions-0.1.0/src/university/subscriptions/payables.py

@@ -0,0 +1,45 @@
+"""How payments charges for a subscription period (Core's payable contract): the platform is the payee."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from university.core.exceptions import NotFound
+from university.core.ids import is_valid_uuid
+from university.core.payables import Payable, PayableAdapter
+from university.subscriptions.conf import plans
+from university.subscriptions.models import Subscription
+
+
+class PeriodPayable(PayableAdapter):
+    purpose = "subscriptions.period"
+    label = "Subscription"
+
+    def resolve(self, object_id: Any, payer: Any) -> Payable:
+        from university.subscriptions.services import amount_due
+
+        sub = Subscription.objects.filter(pk=object_id).first() if is_valid_uuid(object_id) else None
+        due = amount_due(sub) if sub is not None and sub.user_id == getattr(payer, "pk", None) else None
+        if sub is None or due is None:
+            raise NotFound("Nothing is due on this subscription.")
+        name = plans().get(sub.plan, {}).get("name", sub.plan)
+        return Payable(
+            purpose=self.purpose,
+            object_id=str(sub.pk),
+            payer_id=str(sub.user_id),
+            amount_minor=due,
+            currency=sub.currency,
+            description=f"{name} ({sub.get_interval_display().lower()})"[:120],
+            platform_fee_minor=due,
+            metadata={"subscription_id": str(sub.pk), "plan": sub.plan, "interval": sub.interval},
+        )
+
+    def on_paid(self, object_id: Any, *, reference: str, amount_minor: int, currency: str) -> None:
+        from university.subscriptions.services import pay_period
+
+        pay_period(object_id, reference=reference, amount_minor=amount_minor, currency=currency)
+
+    def on_refunded(self, object_id: Any, *, reference: str, amount_minor: int, currency: str) -> None:
+        from university.subscriptions.services import refund_period
+
+        refund_period(reference)

university_subscriptions-0.1.0/src/university/subscriptions/services.py

@@ -0,0 +1,210 @@
+"""Subscriptions: members pay for a period at a time and hold their plan's entitlements meanwhile.
+
+Rules:
+
+* One live subscription per member (pending, active or in its grace period). Changing plan means
+  letting the current one end first: nobody pays twice for overlapping time.
+* Periods are paid through university-payments (purpose ``subscriptions.period``). A payment
+  that arrives when nothing is due (a double payment) is refused, and payments refunds it.
+* Renewals are paid by the member (no stored cards): a reminder goes out before the period ends,
+  and entitlements continue through a short grace period before the subscription expires.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+from django.db import IntegrityError, transaction
+from django.utils import timezone
+
+from university.audit.services import record as audit
+from university.core import entitlements as core_entitlements
+from university.core.events import publish
+from university.core.exceptions import Conflict, NotFound, ValidationError
+from university.core.ids import is_valid_uuid
+from university.subscriptions import events
+from university.subscriptions.conf import plans, price
+from university.subscriptions.conf import subscriptions_settings as conf
+from university.subscriptions.models import ENTITLED, LIVE, Period, Subscription, SubscriptionStatus
+
+PURPOSE = "subscriptions.period"
+
+
+def _payload(sub: Subscription) -> dict[str, Any]:
+    return {"subscription_id": sub.pk, "user_id": sub.user_id, "plan": sub.plan}
+
+
+def current(user: Any) -> Subscription | None:
+    """The member's live subscription, if any."""
+    if user is None or not getattr(user, "is_authenticated", False):
+        return None
+    return Subscription.objects.filter(user=user, status__in=LIVE).first()
+
+
+def user_entitlements(user: Any) -> list[str]:
+    """Core hook: the entitlements of the member's plan while it's paid up (or in grace)."""
+    sub = Subscription.objects.filter(user=user, status__in=ENTITLED).only("plan").first()
+    if sub is None:
+        return []
+    return list(plans().get(sub.plan, {}).get("entitlements", []))
+
+
+def subscribe(*, user: Any, plan: str, interval: str, currency: str) -> Subscription:
+    if plan not in plans():
+        raise ValidationError(details={"plan": ["Unknown plan."]})
+    if price(plan, interval, currency) is None:
+        raise ValidationError(details={"interval": ["This plan isn't sold for that interval and currency."]})
+    with transaction.atomic():
+        existing = Subscription.objects.select_for_update().filter(user=user, status__in=LIVE).first()
+        if existing is not None and existing.status != SubscriptionStatus.PENDING_PAYMENT:
+            raise Conflict(
+                "You already have a subscription. Let it end before choosing another plan.", code="already_subscribed"
+            )
+        if existing is not None:
+            # Not paid yet: just change what they're about to buy.
+            existing.plan, existing.interval, existing.currency = plan, interval, currency
+            existing.save(update_fields=["plan", "interval", "currency", "updated_at"])
+            return existing
+        try:
+            with transaction.atomic():
+                sub = Subscription.objects.create(user=user, plan=plan, interval=interval, currency=currency)
+        except IntegrityError:
+            raise Conflict("You already have a subscription.", code="already_subscribed") from None
+    audit("subscriptions.subscription.started", actor=user, target=sub, category="payments")
+    return sub
+
+
+def abandon(*, user: Any) -> None:
+    """Drop an unpaid subscription (e.g. the member changed their mind at checkout)."""
+    updated = Subscription.objects.filter(user=user, status=SubscriptionStatus.PENDING_PAYMENT).update(
+        status=SubscriptionStatus.ABANDONED
+    )
+    if not updated:
+        raise NotFound("Nothing to cancel.")
+
+
+def set_cancel_at_period_end(*, user: Any, cancel: bool) -> Subscription:
+    sub = Subscription.objects.filter(user=user, status__in=ENTITLED).first()
+    if sub is None:
+        raise NotFound("You don't have an active subscription.")
+    sub.cancel_at_period_end = cancel
+    sub.save(update_fields=["cancel_at_period_end", "updated_at"])
+    audit(
+        "subscriptions.subscription.cancelled" if cancel else "subscriptions.subscription.resumed",
+        actor=user,
+        target=sub,
+        category="payments",
+    )
+    return sub
+
+
+def amount_due(sub: Subscription, *, now: dt.datetime | None = None) -> int | None:
+    """What paying now costs, or None when nothing is due yet (or the plan is no longer sold)."""
+    now = now or timezone.now()
+    if sub.status == SubscriptionStatus.ACTIVE:
+        window = dt.timedelta(days=int(conf.get("RENEWAL_WINDOW_DAYS", 7)))
+        if sub.current_period_end is None or sub.current_period_end - now > window:
+            return None
+    elif sub.status not in (SubscriptionStatus.PENDING_PAYMENT, SubscriptionStatus.PAST_DUE):
+        return None
+    return price(sub.plan, sub.interval, sub.currency)
+
+
+def pay_period(object_id: Any, *, reference: str, amount_minor: int, currency: str) -> Subscription:
+    """A period was paid: activate or extend. Called by the payable adapter."""
+    with transaction.atomic():
+        sub = (
+            Subscription.objects.select_for_update().filter(pk=object_id).first() if is_valid_uuid(object_id) else None
+        )
+        if sub is None:
+            raise NotFound("No such subscription.")
+        due = amount_due(sub)
+        if due is None or due != amount_minor or currency != sub.currency:
+            raise Conflict("Nothing is due on this subscription.", code="not_due")
+        now = timezone.now()
+        first = sub.status == SubscriptionStatus.PENDING_PAYMENT
+        # An early renewal continues from the end of the paid time; a new or lapsed one starts now.
+        restart = first or sub.status == SubscriptionStatus.PAST_DUE or sub.current_period_end is None
+        start = now if restart else max(now, sub.current_period_end)
+        end = start + dt.timedelta(days=int(conf.get("INTERVAL_DAYS", {}).get(sub.interval, 30)))
+        Period.objects.create(
+            subscription=sub,
+            starts_at=start,
+            ends_at=end,
+            amount_minor=amount_minor,
+            currency=currency,
+            payment_reference=reference,
+        )
+        if restart:
+            sub.current_period_start = start
+        sub.current_period_end = end
+        sub.status = SubscriptionStatus.ACTIVE
+        sub.cancel_at_period_end = False
+        sub.save()
+    core_entitlements.forget(sub.user)
+    publish(events.SUBSCRIPTION_ACTIVATED if first else events.SUBSCRIPTION_RENEWED, _payload(sub))
+    audit("subscriptions.period.paid", actor=None, target=sub, category="payments", metadata={"reference": reference})
+    return sub
+
+
+def refund_period(reference: str) -> None:
+    """A paid period was refunded: take that time back. Payments that bought nothing are no-ops."""
+    with transaction.atomic():
+        period = Period.objects.select_related("subscription").filter(payment_reference=reference).first()
+        if period is None:
+            return
+        sub = Subscription.objects.select_for_update().get(pk=period.subscription_id)
+        length = period.ends_at - period.starts_at
+        if sub.current_period_end is not None:
+            sub.current_period_end = max(period.starts_at, sub.current_period_end - length)
+            sub.save(update_fields=["current_period_end", "updated_at"])
+        period.delete()
+    audit(
+        "subscriptions.period.refunded", actor=None, target=sub, category="payments", metadata={"reference": reference}
+    )
+    if sub.current_period_end is None or sub.current_period_end <= timezone.now():
+        _expire(sub)
+    core_entitlements.forget(sub.user)
+
+
+def sweep(*, now: dt.datetime | None = None) -> dict[str, int]:
+    """Move subscriptions along as time passes: reminders, grace and expiry. Safe to run often."""
+    now = now or timezone.now()
+    counts = {"reminded": 0, "past_due": 0, "expired": 0}
+    reminder_at = now + dt.timedelta(days=int(conf.get("REMINDER_DAYS", 3)))
+    for sub in Subscription.objects.filter(
+        status=SubscriptionStatus.ACTIVE,
+        cancel_at_period_end=False,
+        current_period_end__lte=reminder_at,
+        current_period_end__gt=now,
+    ):
+        if sub.reminded_for != sub.current_period_end:
+            Subscription.objects.filter(pk=sub.pk).update(reminded_for=sub.current_period_end)
+            publish(events.SUBSCRIPTION_RENEWAL_DUE, _payload(sub))
+            counts["reminded"] += 1
+    ended = Subscription.objects.filter(status=SubscriptionStatus.ACTIVE, current_period_end__lte=now)
+    for sub in ended:
+        if sub.cancel_at_period_end:
+            _expire(sub)
+            counts["expired"] += 1
+        else:
+            Subscription.objects.filter(pk=sub.pk, status=SubscriptionStatus.ACTIVE).update(
+                status=SubscriptionStatus.PAST_DUE
+            )
+            counts["past_due"] += 1
+    grace = dt.timedelta(days=int(conf.get("GRACE_DAYS", 3)))
+    for sub in Subscription.objects.filter(status=SubscriptionStatus.PAST_DUE, current_period_end__lte=now - grace):
+        _expire(sub)
+        counts["expired"] += 1
+    stale = now - dt.timedelta(days=2)
+    Subscription.objects.filter(status=SubscriptionStatus.PENDING_PAYMENT, created_at__lte=stale).update(
+        status=SubscriptionStatus.ABANDONED
+    )
+    return counts
+
+
+def _expire(sub: Subscription) -> None:
+    updated = Subscription.objects.filter(pk=sub.pk, status__in=ENTITLED).update(status=SubscriptionStatus.EXPIRED)
+    if updated:
+        publish(events.SUBSCRIPTION_EXPIRED, _payload(sub))

university_subscriptions-0.1.0/tests/conftest.py

@@ -0,0 +1 @@
+from university.core.testing import *  # noqa: F403

university_subscriptions-0.1.0/tests/settings.py

@@ -0,0 +1,14 @@
+from university.core import CORE_APPS
+from university.core.testing import build_test_settings
+
+globals().update(
+    build_test_settings(
+        installed_apps=["drf_spectacular", *CORE_APPS, "university.subscriptions"],
+        root_urlconf="tests.urls",
+        STORAGES={
+            "default": {"BACKEND": "django.core.files.storage.InMemoryStorage"},
+            "private": {"BACKEND": "django.core.files.storage.InMemoryStorage"},
+            "staticfiles": {"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage"},
+        },
+    )
+)

university_subscriptions-0.1.0/tests/test_subscriptions.py

@@ -0,0 +1,185 @@
+"""Subscriptions: plans, paying periods, renewals, grace, expiry, refunds and entitlements."""
+
+from __future__ import annotations
+
+import datetime as dt
+
+import pytest
+from django.utils import timezone
+
+from university.core.entitlements import entitlements, forget, has_entitlement
+from university.core.exceptions import Conflict, NotFound
+from university.core.payables import get_payable_adapter
+from university.core.testing import create_user
+from university.subscriptions import services
+from university.subscriptions.models import Subscription
+
+pytestmark = pytest.mark.django_db
+BASE = "/api/v1/subscriptions"
+PRICE = 150000
+
+
+def subscribe(client, plan="plus", interval="month"):
+    response = client.post(f"{BASE}/me/", {"plan": plan, "interval": interval, "currency": "NGN"}, format="json")
+    assert response.status_code == 201, response.json()
+    return response.json()
+
+
+def pay(sub_id, reference="ref-1", amount=PRICE):
+    get_payable_adapter("subscriptions.period").on_paid(
+        sub_id, reference=reference, amount_minor=amount, currency="NGN"
+    )
+
+
+def test_plans_public(api_client):
+    body = api_client.get(f"{BASE}/plans/").json()
+    plus = next(p for p in body if p["key"] == "plus")
+    assert {"interval": "month", "currency": "NGN", "amount_minor": PRICE} in plus["prices"]
+    assert {"key": "premium.ad_free", "label": "No adverts"} in plus["entitlements"]
+
+
+def test_subscribe_pay_and_hold_entitlements(auth_client, user):
+    client = auth_client(user)
+    sub = subscribe(client)
+    assert sub["status"] == "pending_payment"
+    assert sub["payment_due"] == {
+        "purpose": "subscriptions.period",
+        "object_id": sub["id"],
+        "amount_minor": PRICE,
+        "currency": "NGN",
+    }
+    assert not has_entitlement(user, "premium.ad_free")
+    payable = get_payable_adapter("subscriptions.period").resolve(sub["id"], user)
+    assert payable.amount_minor == PRICE and payable.payee_id is None and payable.platform_fee_minor == PRICE
+    pay(sub["id"])
+    forget(user)
+    assert has_entitlement(user, "premium.ad_free") and has_entitlement(user, "premium.badge")
+    me = client.get(f"{BASE}/me/").json()
+    assert me["subscription"]["status"] == "active" and me["subscription"]["payment_due"] is None
+    assert "premium.badge" in me["entitlements"] and len(me["subscription"]["periods"]) == 1
+
+
+def test_nobody_else_can_pay_and_double_payments_are_refused(auth_client, user):
+    sub = subscribe(auth_client(user))
+    with pytest.raises(NotFound):
+        get_payable_adapter("subscriptions.period").resolve(
+            sub["id"], create_user(handle="payer2", email="payer2@example.com")
+        )
+    pay(sub["id"])
+    # Nothing due now: a second checkout can't start, and a second payment can't be applied.
+    with pytest.raises(NotFound):
+        get_payable_adapter("subscriptions.period").resolve(sub["id"], user)
+    with pytest.raises(Conflict):
+        pay(sub["id"], reference="ref-2")
+    # The wrong amount is refused too (payments then refunds it).
+    Subscription.objects.filter(pk=sub["id"]).update(status="pending_payment")
+    with pytest.raises(Conflict):
+        pay(sub["id"], reference="ref-3", amount=1)
+
+
+def test_one_live_subscription_and_plan_change_before_paying(auth_client, user):
+    client = auth_client(user)
+    first = subscribe(client)
+    changed = subscribe(client, plan="creator_pro", interval="year")
+    assert changed["id"] == first["id"] and changed["plan"] == "creator_pro"
+    pay(changed["id"], amount=5000000)
+    assert client.post(f"{BASE}/me/", {"plan": "plus", "interval": "month"}, format="json").status_code == 409
+    assert client.post(f"{BASE}/me/", {"plan": "gold", "interval": "month"}, format="json").status_code == 400
+
+
+def test_renewal_window_extends_from_period_end(auth_client, user):
+    sub = subscribe(auth_client(user))
+    pay(sub["id"])
+    obj = Subscription.objects.get(pk=sub["id"])
+    end = obj.current_period_end
+    assert services.amount_due(obj) is None
+    Subscription.objects.filter(pk=obj.pk).update(current_period_end=timezone.now() + dt.timedelta(days=2))
+    obj.refresh_from_db()
+    assert services.amount_due(obj) == PRICE
+    pay(sub["id"], reference="ref-renew")
+    obj.refresh_from_db()
+    assert obj.current_period_end > end
+    assert abs((obj.current_period_end - timezone.now()) - dt.timedelta(days=32)) < dt.timedelta(minutes=1)
+
+
+def test_sweep_reminds_then_grace_then_expires(auth_client, user):
+    from university.core.events import event_bus
+
+    sub = subscribe(auth_client(user))
+    pay(sub["id"])
+    seen = []
+    event_bus.subscribe("subscriptions.*", seen.append)
+    try:
+        Subscription.objects.filter(pk=sub["id"]).update(current_period_end=timezone.now() + dt.timedelta(days=1))
+        assert services.sweep()["reminded"] == 1
+        assert services.sweep()["reminded"] == 0  # once per period
+        Subscription.objects.filter(pk=sub["id"]).update(current_period_end=timezone.now() - dt.timedelta(hours=1))
+        assert services.sweep()["past_due"] == 1
+        forget(user)
+        assert has_entitlement(user, "premium.ad_free")  # grace period
+        Subscription.objects.filter(pk=sub["id"]).update(current_period_end=timezone.now() - dt.timedelta(days=4))
+        assert services.sweep()["expired"] == 1
+    finally:
+        event_bus.unsubscribe("subscriptions.*", seen.append)
+    forget(user)
+    assert entitlements(user) == frozenset()
+    assert [e.name for e in seen] == ["subscriptions.subscription.renewal_due", "subscriptions.subscription.expired"]
+
+
+def test_lapsed_subscription_can_be_paid_in_grace(auth_client, user):
+    sub = subscribe(auth_client(user))
+    pay(sub["id"])
+    Subscription.objects.filter(pk=sub["id"]).update(
+        status="past_due", current_period_end=timezone.now() - dt.timedelta(days=1)
+    )
+    pay(sub["id"], reference="ref-late")
+    obj = Subscription.objects.get(pk=sub["id"])
+    assert obj.status == "active" and obj.current_period_end > timezone.now() + dt.timedelta(days=29)
+
+
+def test_cancel_at_period_end(auth_client, user):
+    client = auth_client(user)
+    sub = subscribe(client)
+    assert client.post(f"{BASE}/me/cancel/", {}, format="json").status_code == 404
+    pay(sub["id"])
+    assert client.post(f"{BASE}/me/cancel/", {}, format="json").json()["cancel_at_period_end"] is True
+    Subscription.objects.filter(pk=sub["id"]).update(current_period_end=timezone.now() + dt.timedelta(days=1))
+    assert services.sweep()["reminded"] == 0
+    Subscription.objects.filter(pk=sub["id"]).update(current_period_end=timezone.now() - dt.timedelta(minutes=1))
+    assert services.sweep()["expired"] == 1
+    assert client.get(f"{BASE}/me/").json()["subscription"] is None
+    # A new plan can be chosen once the old one ended.
+    assert subscribe(client)["status"] == "pending_payment"
+
+
+def test_abandon_unpaid(auth_client, user):
+    client = auth_client(user)
+    subscribe(client)
+    assert client.delete(f"{BASE}/me/").status_code == 204
+    assert client.delete(f"{BASE}/me/").status_code == 404
+    assert client.get(f"{BASE}/me/").json()["subscription"] is None
+
+
+def test_refund_takes_time_back(auth_client, user):
+    sub = subscribe(auth_client(user))
+    pay(sub["id"])
+    adapter = get_payable_adapter("subscriptions.period")
+    adapter.on_refunded(sub["id"], reference="unrelated", amount_minor=PRICE, currency="NGN")  # no-op
+    assert Subscription.objects.get(pk=sub["id"]).status == "active"
+    adapter.on_refunded(sub["id"], reference="ref-1", amount_minor=PRICE, currency="NGN")
+    assert Subscription.objects.get(pk=sub["id"]).status == "expired"
+    forget(user)
+    assert not has_entitlement(user, "premium.ad_free")
+
+
+def test_public_badge_export_and_purge(auth_client, api_client, user):
+    from university.subscriptions.integrations import export_data, purge
+
+    sub = subscribe(auth_client(user))
+    assert api_client.get(f"/api/v1/users/by-handle/{user.handle}/").json()["extras"]["premium"] is False
+    pay(sub["id"])
+    assert api_client.get(f"/api/v1/users/by-handle/{user.handle}/").json()["extras"]["premium"] is True
+    exported = export_data(user)["subscriptions"][0]
+    assert exported["plan"] == "plus" and exported["periods"][0]["amount_minor"] == PRICE
+    purge(user.pk)
+    assert not Subscription.objects.exists()

university_subscriptions-0.1.0/tests/urls.py

@@ -0,0 +1,3 @@
+from django.urls import include, path
+
+urlpatterns = [path("", include("university.core.urls"))]