[Offering] Partnership: Account Benefit registration code (#2935)

* feat(#2924): Account Benefit registration code required unless linked to Partnership

* feat(#2924): Fix tests

* fix(#2924): Fix faker

Author: pbanaszkiewicz

src/extrequests/tests/test_forms.py

@@ -377,6 +377,7 @@ def test_clean__valid_data__benefit(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             start_date=date.today() - timedelta(days=1),
             end_date=date.today() + timedelta(days=365),
             allocation=2,
@@ -451,6 +452,7 @@ def test_clean__benefit_with_membership_or_auto_assign(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             start_date=date.today() - timedelta(days=1),
             end_date=date.today() + timedelta(days=365),
             allocation=2,
@@ -504,6 +506,7 @@ def test_clean__auto_assign_with_membership_or_benefit(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             start_date=date.today() - timedelta(days=1),
             end_date=date.today() + timedelta(days=365),
             allocation=2,
@@ -570,6 +573,7 @@ def test_clean__benefit_override(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             start_date=date.today() - timedelta(days=1),
             end_date=date.today() + timedelta(days=365),
             allocation=2,

src/extrequests/tests/test_training_request.py

@@ -414,6 +414,7 @@ def test_successful_matching_to_allocated_benefit(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             allocation=5,
             start_date=date.today(),
             end_date=date.today() + timedelta(days=365),

src/extrequests/tests/test_utils.py

@@ -429,6 +429,7 @@ def test_creates_task_linked_to_benefit(self) -> None:
         account_benefit = AccountBenefit.objects.create(
             account=account,
             benefit=benefit,
+            registration_code="test-code",
             start_date=date.today() - timedelta(days=1),
             end_date=date.today() + timedelta(days=30),
             allocation=1,
@@ -682,6 +683,7 @@ def make_account_benefit(
         return AccountBenefit.objects.create(
             account=self.account,
             benefit=self.benefit,
+            registration_code="test-code",
             start_date=date.today() + timedelta(days=start_offset),
             end_date=date.today() + timedelta(days=end_offset),
             allocation=allocation,

src/offering/forms.py

@@ -187,6 +187,7 @@ def __init__(
         disable_account: bool = False,
         disable_partnership: bool = False,
         disable_dates: bool = False,
+        disable_registration_code: bool = False,
         **kwargs: Any,
     ) -> None:
         super().__init__(*args, **kwargs)
@@ -198,6 +199,8 @@ def __init__(
         if disable_dates:
             self.fields["start_date"].disabled = True
             self.fields["end_date"].disabled = True
+        if disable_registration_code:
+            self.fields["registration_code"].disabled = True
 
         # If these fields are disabled, the browser won't send their values and this trips the validation
         # (unless we make them not required).
@@ -208,9 +211,22 @@ def clean(self) -> dict[str, Any]:
         cleaned_data = cast(dict[str, Any], super().clean())
         errors = {}
 
-        # Ensure unique registration code across Memberships and Partnerships.
+        partnership = cleaned_data.get("partnership")
+
+        # `registration_code` is required when no partnership, and must be empty when partnership is set
         registration_code = cleaned_data.get("registration_code")
-        if registration_code:
+        # This repeats the logic from the model constraint, but allows for better error messages.
+        if partnership and registration_code:
+            errors["registration_code"] = ValidationError(
+                "Registration code must be empty when a partnership is selected."
+            )
+        elif not partnership and not registration_code:
+            errors["registration_code"] = ValidationError(
+                "Registration code is required when no partnership is selected."
+            )
+
+        # Ensure unique registration code across Memberships and Partnerships.
+        elif registration_code and not partnership:
             existing_membership = Membership.objects.filter(registration_code=registration_code).first()
             if existing_membership:
                 errors["registration_code"] = ValidationError(
@@ -224,7 +240,6 @@ def clean(self) -> dict[str, Any]:
 
         # Verify if partnership belongs to the account
         account = cleaned_data["account"]
-        partnership = cleaned_data["partnership"]
         if partnership and partnership.account != account:
             errors["partnership"] = ValidationError("Selected partnership does not belong to the selected account.")
 

src/offering/migrations/0007_alter_accountbenefit_registration_code_and_more.py

@@ -0,0 +1,64 @@
+# Generated by Django 5.2.12 on 2026-03-15 16:06
+
+from uuid import uuid4
+
+from django.db import migrations, models
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.migrations.state import StateApps
+
+
+def set_registration_code_to_fulfill_constraint(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    AccountBenefit = apps.get_model("offering", "AccountBenefit")
+
+    # To satisfy the new constraint, we need to ensure that all AccountBenefits linked to a partnership have a null
+    # registration code, and all AccountBenefits not linked to a partnership have a non-null registration code.
+    for account_benefit in AccountBenefit.objects.filter(partnership__isnull=True, registration_code__isnull=True):
+        account_benefit.registration_code = str(uuid4())
+        account_benefit.save()
+
+    for account_benefit in AccountBenefit.objects.filter(partnership__isnull=False, registration_code__isnull=False):
+        account_benefit.registration_code = None
+        account_benefit.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("fiscal", "0005_alter_partnership_tier"),
+        ("offering", "0006_accountbenefit_registration_code"),
+        ("workshops", "0292_alter_trainingrequest_member_code_and_more"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            set_registration_code_to_fulfill_constraint,
+            migrations.RunPython.noop,
+        ),
+        migrations.AlterField(
+            model_name="accountbenefit",
+            name="registration_code",
+            field=models.CharField(
+                blank=True,
+                help_text="Unique registration code used for account benefit identification. "
+                "Required if the account benefit is not linked to a partnership. If the account benefit is"
+                " linked to a partnership, the registration code will be inherited from the partnership and cannot be"
+                " set directly on the account benefit.",
+                max_length=40,
+                null=True,
+                unique=True,
+                verbose_name="Registration Code",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="accountbenefit",
+            constraint=models.CheckConstraint(
+                condition=models.Q(
+                    models.Q(("partnership__isnull", False), ("registration_code__isnull", True)),
+                    models.Q(("partnership__isnull", True), ("registration_code__isnull", False)),
+                    _connector="OR",
+                ),
+                name="check_partnership_registration_code",
+                violation_error_message="Account Benefit, if linked to partnership, cannot have a registration code. "
+                "If not linked to partnership, the registration code is required.",
+            ),
+        ),
+    ]

src/offering/models.py

@@ -135,14 +135,29 @@ class AccountBenefit(CreatedUpdatedMixin, models.Model):
         blank=True,
         unique=True,
         verbose_name="Registration Code",
-        help_text="Unique registration code used for account benefit identification.",
+        help_text="Unique registration code used for account benefit identification. "
+        "Required if the account benefit is not linked to a partnership. If the account benefit is linked "
+        "to a partnership, the registration code will be inherited from the partnership and cannot be set directly on "
+        "the account benefit.",
     )
 
     start_date = models.DateField()
     end_date = models.DateField()
     allocation = models.PositiveIntegerField()
     frozen = models.BooleanField(default=False)
 
+    class Meta:
+        constraints = [
+            # Account Benefit linked to a partnership cannot have a registration code (it should use partnership's code)
+            models.CheckConstraint(
+                condition=(Q(partnership__isnull=False) & Q(registration_code__isnull=True))
+                | (Q(partnership__isnull=True) & Q(registration_code__isnull=False)),
+                name="check_partnership_registration_code",
+                violation_error_message="Account Benefit, if linked to partnership, cannot have a registration code. "
+                "If not linked to partnership, the registration code is required.",
+            ),
+        ]
+
     @property
     def human_daterange(self) -> str:
         return human_daterange(self.start_date, self.end_date)

src/offering/tests/test_forms.py

@@ -57,6 +57,18 @@ def test_fields_disabled(self) -> None:
         self.assertTrue(form.fields["start_date"].disabled)
         self.assertTrue(form.fields["end_date"].disabled)
 
+    def test_registration_code_field_disabled(self) -> None:
+        # Act
+        form = AccountBenefitForm(disable_registration_code=True)
+        # Assert
+        self.assertTrue(form.fields["registration_code"].disabled)
+
+    def test_registration_code_field_enabled_by_default(self) -> None:
+        # Act
+        form = AccountBenefitForm()
+        # Assert
+        self.assertFalse(form.fields["registration_code"].disabled)
+
     def test_clean__valid(self) -> None:
         # Arrange
         org = Organization.objects.create(fullname="Test Org", domain="example.com")
@@ -72,6 +84,7 @@ def test_clean__valid(self) -> None:
         data = {
             "account": account.pk,
             "benefit": benefit.pk,
+            "registration_code": "TESTCODE",
             "start_date": "2025-01-01",
             "end_date": "2025-12-31",
             "allocation": 10,
@@ -283,8 +296,73 @@ def test_clean__registration_code_unique(self) -> None:
         # Assert
         self.assertTrue(form.is_valid())
 
+    def test_clean__valid__with_partnership(self) -> None:
+        """Form is valid when partnership is set and registration code is absent."""
+        # Arrange
+        org = Organization.objects.create(fullname="Test Org", domain="example.com")
+        account = Account.objects.create(
+            account_type=Account.AccountTypeChoices.ORGANISATION,
+            generic_relation=org,
+        )
+        partnership = Partnership.objects.create(
+            name="Test Partnership",
+            partner_organisation=org,
+            account=account,
+            agreement_start=date(2025, 1, 1),
+            agreement_end=date(2025, 12, 31),
+            credits=10,
+        )
+        benefit = Benefit.objects.create(name="Test Benefit", unit_type="seat", credits=2)
+        data = {
+            "account": account.pk,
+            "partnership": partnership.pk,
+            "benefit": benefit.pk,
+            "registration_code": "",
+            "allocation": 10,
+        }
+
+        # Act
+        form = AccountBenefitForm(data)
+
+        # Assert
+        self.assertTrue(form.is_valid())
+
+    def test_clean__registration_code_present_with_partnership(self) -> None:
+        """Form is invalid when both a partnership and a registration code are provided."""
+        # Arrange
+        org = Organization.objects.create(fullname="Test Org", domain="example.com")
+        account = Account.objects.create(
+            account_type=Account.AccountTypeChoices.ORGANISATION,
+            generic_relation=org,
+        )
+        partnership = Partnership.objects.create(
+            name="Test Partnership",
+            partner_organisation=org,
+            account=account,
+            agreement_start=date(2025, 1, 1),
+            agreement_end=date(2025, 12, 31),
+            credits=10,
+        )
+        benefit = Benefit.objects.create(name="Test Benefit", unit_type="seat", credits=2)
+        data = {
+            "account": account.pk,
+            "partnership": partnership.pk,
+            "benefit": benefit.pk,
+            "registration_code": "SHOULD-NOT-BE-HERE",
+            "allocation": 10,
+        }
+
+        # Act
+        form = AccountBenefitForm(data)
+
+        # Assert
+        self.assertFalse(form.is_valid())
+        self.assertIn(
+            "Registration code must be empty when a partnership is selected.", form.errors["registration_code"]
+        )
+
     def test_clean__registration_code_empty(self) -> None:
-        """Form is valid when registration code is empty (it's optional)."""
+        """Form is invalid when registration code is empty and no partnership is selected."""
         # Arrange
         org = Organization.objects.create(fullname="Test Org", domain="example.com")
         account = Account.objects.create(
@@ -305,4 +383,5 @@ def test_clean__registration_code_empty(self) -> None:
         form = AccountBenefitForm(data)
 
         # Assert
-        self.assertTrue(form.is_valid())
+        self.assertFalse(form.is_valid())
+        self.assertIn("registration_code", form.errors)

src/offering/tests/test_views.py

@@ -179,3 +179,4 @@ def test_get_form_kwargs(self) -> None:
         self.assertTrue(result["disable_account"])
         self.assertTrue(result["disable_partnership"])
         self.assertTrue(result["disable_dates"])
+        self.assertTrue(result["disable_registration_code"])

src/offering/views.py

@@ -351,6 +351,7 @@ def get_form_kwargs(self) -> dict[str, Any]:
         if kwargs.get("initial", {}).get("partnership") is not None:
             kwargs["disable_partnership"] = True
             kwargs["disable_dates"] = True
+            kwargs["disable_registration_code"] = True
 
         return kwargs
 

src/static/offering_account_benefit_for_partnership_form.js

@@ -18,10 +18,21 @@ jQuery(function () {
       id_end_date.removeAttr("disabled");
     }
   }
+  function handleRegistrationCode(record) {
+    const id_registration_code = $("#id_registration_code");
+    if (record.id) {
+      id_registration_code.attr("disabled", "disabled");
+      id_registration_code.removeAttr("required");
+    } else {
+      id_registration_code.removeAttr("disabled");
+      id_registration_code.attr("required", "required");
+    }
+  }
 
   $("#id_partnership").on("change.select2", (e) => {
     const record = $(e.target).select2("data")[0];
     handleDateFields(record);
+    handleRegistrationCode(record);
     e.preventDefault();
   });