Add Django command to backfill grant reimbursements

Add a Django management command to migrate old grant data to the new
reimbursement model. This command will:

- Create default reimbursement categories for each conference
- Convert approved_type and amount fields into GrantReimbursement records
- Validate data integrity by comparing totals before and after migration

The migration preserves the full history of grant amounts while moving to
the new flexible category system.

Author: estyxx

backend/grants/management/commands/__init__.py

@@ -0,0 +1,127 @@
+from decimal import Decimal
+
+from django.core.management.base import BaseCommand
+from grants.models import Grant, GrantReimbursement, GrantReimbursementCategory
+from conferences.models import Conference
+
+
+class Command(BaseCommand):
+    help = "Backfill GrantReimbursement entries from approved_type data on approved grants."
+
+    def handle(self, *args, **options):
+        self.stdout.write("🚀 Starting backfill of grant reimbursements...")
+
+        self._ensure_categories_exist()
+        self._migrate_grants()
+        self._validate_migration()
+
+        self.stdout.write(self.style.SUCCESS("✅ Backfill completed successfully."))
+
+    def _ensure_categories_exist(self):
+        for conference in Conference.objects.all():
+            GrantReimbursementCategory.objects.get_or_create(
+                conference=conference,
+                category="ticket",
+                defaults={
+                    "name": "Ticket",
+                    "description": "Conference ticket",
+                    "max_amount": conference.grants_default_ticket_amount
+                    or Decimal("0.00"),
+                    "included_by_default": True,
+                },
+            )
+            GrantReimbursementCategory.objects.get_or_create(
+                conference=conference,
+                category="travel",
+                defaults={
+                    "name": "Travel",
+                    "description": "Travel support",
+                    "max_amount": conference.grants_default_travel_from_extra_eu_amount
+                    or Decimal("400.00"),
+                    "included_by_default": False,
+                },
+            )
+            GrantReimbursementCategory.objects.get_or_create(
+                conference=conference,
+                category="accommodation",
+                defaults={
+                    "name": "Accommodation",
+                    "description": "Accommodation support",
+                    "max_amount": conference.grants_default_accommodation_amount
+                    or Decimal("300.00"),
+                    "included_by_default": True,
+                },
+            )
+
+    def _migrate_grants(self):
+        grants = Grant.objects.filter(approved_type__isnull=False).exclude(
+            approved_type=""
+        )
+
+        self.stdout.write(f"📦 Migrating {grants.count()} grants...")
+
+        for grant in grants:
+            categories = {
+                c.category: c
+                for c in GrantReimbursementCategory.objects.filter(
+                    conference=grant.conference
+                )
+            }
+
+            def add_reimbursement(category_key, amount):
+                if category_key in categories and amount:
+                    GrantReimbursement.objects.get_or_create(
+                        grant=grant,
+                        category=categories[category_key],
+                        defaults={
+                            "granted_amount": amount,
+                        },
+                    )
+
+            add_reimbursement("ticket", grant.ticket_amount)
+
+            if grant.approved_type in ("ticket_travel", "ticket_travel_accommodation"):
+                add_reimbursement("travel", grant.travel_amount)
+
+            if grant.approved_type in (
+                "ticket_accommodation",
+                "ticket_travel_accommodation",
+            ):
+                add_reimbursement("accommodation", grant.accommodation_amount)
+
+    def _validate_migration(self):
+        errors = []
+        grants = Grant.objects.filter(approved_type__isnull=False).exclude(
+            approved_type=""
+        )
+
+        for grant in grants:
+            original_total = sum(
+                filter(
+                    None,
+                    [
+                        grant.ticket_amount,
+                        grant.travel_amount,
+                        grant.accommodation_amount,
+                    ],
+                )
+            )
+            reimbursements_total = sum(
+                r.granted_amount for r in GrantReimbursement.objects.filter(grant=grant)
+            )
+
+            if abs(original_total - reimbursements_total) > Decimal("0.01"):
+                errors.append(
+                    f"Grant ID {grant.id} total mismatch: expected {original_total}, got {reimbursements_total}"
+                )
+
+        if errors:
+            self.stdout.write(
+                self.style.ERROR(f"⚠️ Found {len(errors)} grants with mismatched totals")
+            )
+            for msg in errors:
+                self.stdout.write(self.style.WARNING(f"  {msg}"))
+        else:
+            self.stdout.write(
+                self.style.SUCCESS("🧮 All grant totals match correctly.")
+            )

backend/grants/management/commands/backfill_grant_reimbursements.py

@@ -24,7 +24,7 @@ class Meta:
     description = factory.Faker("sentence")
     max_amount = factory.fuzzy.FuzzyDecimal(50, 500, precision=2)
     category = factory.fuzzy.FuzzyChoice(
-        GrantReimbursementCategory.CategoryType.choices, getter=lambda x: x[0]
+        GrantReimbursementCategory.Category.choices, getter=lambda x: x[0]
     )
     included_by_default = factory.Faker("boolean")
 

backend/grants/tests/factories.py

@@ -0,0 +1,77 @@
+import pytest
+from decimal import Decimal
+from django.core.management import call_command
+from grants.models import GrantReimbursement
+from grants.tests.factories import GrantFactory
+
+
+@pytest.mark.django_db
+@pytest.mark.parametrize(
+    "approved_type,expected_categories",
+    [
+        ("ticket_only", ["ticket"]),
+        ("ticket_travel", ["ticket", "travel"]),
+        ("ticket_accommodation", ["ticket", "accommodation"]),
+        ("ticket_travel_accommodation", ["ticket", "travel", "accommodation"]),
+    ],
+)
+def test_backfill_grant_reimbursements_all_types(approved_type, expected_categories):
+    ticket_amount = Decimal("100.00")
+    travel_amount = Decimal("150.00")
+    accommodation_amount = Decimal("200.00")
+
+    grant = GrantFactory(
+        approved_type=approved_type,
+        status="confirmed",
+        ticket_amount=ticket_amount,
+        travel_amount=travel_amount,
+        accommodation_amount=accommodation_amount,
+    )
+
+    call_command("backfill_grant_reimbursements")
+
+    reimbursements = GrantReimbursement.objects.filter(grant=grant)
+    assert reimbursements.count() == len(expected_categories)
+
+    for category in expected_categories:
+        r = reimbursements.get(category__category=category)
+        if category == "ticket":
+            assert r.granted_amount == ticket_amount
+        elif category == "travel":
+            assert r.granted_amount == travel_amount
+        elif category == "accommodation":
+            assert r.granted_amount == accommodation_amount
+
+
+def test_grant_reimbursement_does_not_duplicate_on_rerun():
+    grant = GrantFactory(
+        approved_type="ticket_travel_accommodation",
+        status="approved",
+        ticket_amount=Decimal("100.00"),
+        travel_amount=Decimal("100.00"),
+        accommodation_amount=Decimal("100.00"),
+    )
+
+    call_command("backfill_grant_reimbursements")
+    initial_count = GrantReimbursement.objects.filter(grant=grant).count()
+    assert initial_count == 3
+
+    call_command("backfill_grant_reimbursements")
+    second_count = GrantReimbursement.objects.filter(grant=grant).count()
+    assert second_count == 3  # no duplicates
+
+
+def test_total_amount_consistency():
+    grant = GrantFactory(
+        approved_type="ticket_travel",
+        status="approved",
+        ticket_amount=Decimal("120.00"),
+        travel_amount=Decimal("80.00"),
+        accommodation_amount=Decimal("0.00"),
+    )
+
+    call_command("backfill_grant_reimbursements")
+    reimbursements = GrantReimbursement.objects.filter(grant=grant)
+    total = sum(r.granted_amount for r in reimbursements)
+    expected = grant.ticket_amount + grant.travel_amount
+    assert total == expected