From d9b98ae66247882b237eeb6a11942ca572a80f66 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 13:39:14 -0700
Subject: [PATCH 01/53] Change namespace to signed_agreements instead of
 agreements

This is to handle a page for agreement versions - it's a little
clearer.
---
 primed/cdsa/models.py                |  6 +++---
 primed/cdsa/tests/test_views.py      | 22 +++++++++++-----------
 primed/cdsa/urls.py                  | 12 ++++++++----
 primed/templates/cdsa/nav_items.html | 20 ++++++++++----------
 4 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 4605f305..e30bbfd4 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -185,7 +185,7 @@ class MemberAgreement(TimeStampedModel, AgreementTypeModel, models.Model):
 
     def get_absolute_url(self):
         return reverse(
-            "cdsa:agreements:members:detail",
+            "cdsa:signed_agreements:members:detail",
             kwargs={"cc_id": self.signed_agreement.cc_id},
         )
 
@@ -207,7 +207,7 @@ class DataAffiliateAgreement(TimeStampedModel, AgreementTypeModel, models.Model)
 
     def get_absolute_url(self):
         return reverse(
-            "cdsa:agreements:data_affiliates:detail",
+            "cdsa:signed_agreements:data_affiliates:detail",
             kwargs={"cc_id": self.signed_agreement.cc_id},
         )
 
@@ -226,7 +226,7 @@ class NonDataAffiliateAgreement(TimeStampedModel, AgreementTypeModel, models.Mod
 
     def get_absolute_url(self):
         return reverse(
-            "cdsa:agreements:non_data_affiliates:detail",
+            "cdsa:signed_agreements:non_data_affiliates:detail",
             kwargs={"cc_id": self.signed_agreement.cc_id},
         )
 
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 6d928f06..728a9476 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -56,7 +56,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:list", args=args)
+        return reverse("cdsa:signed_agreements:list", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -136,7 +136,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:members:new", args=args)
+        return reverse("cdsa:signed_agreements:members:new", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -977,7 +977,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:members:detail", args=args)
+        return reverse("cdsa:signed_agreements:members:detail", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -1061,7 +1061,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:members:list", args=args)
+        return reverse("cdsa:signed_agreements:members:list", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -1139,7 +1139,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:data_affiliates:new", args=args)
+        return reverse("cdsa:signed_agreements:data_affiliates:new", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -2125,7 +2125,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:data_affiliates:detail", args=args)
+        return reverse("cdsa:signed_agreements:data_affiliates:detail", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -2215,7 +2215,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:data_affiliates:list", args=args)
+        return reverse("cdsa:signed_agreements:data_affiliates:list", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -2293,7 +2293,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:non_data_affiliates:new", args=args)
+        return reverse("cdsa:signed_agreements:non_data_affiliates:new", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -3118,7 +3118,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:non_data_affiliates:detail", args=args)
+        return reverse("cdsa:signed_agreements:non_data_affiliates:detail", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -3196,7 +3196,7 @@ def setUp(self):
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
-        return reverse("cdsa:agreements:non_data_affiliates:list", args=args)
+        return reverse("cdsa:signed_agreements:non_data_affiliates:list", args=args)
 
     def get_view(self):
         """Return the view being tested."""
@@ -3358,7 +3358,7 @@ def setUp(self):
     def get_url(self, *args):
         """Get the url for the view being tested."""
         return reverse(
-            "cdsa:audit:agreements",
+            "cdsa:audit:signed_agreements",
             args=args,
         )
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index a96e7715..5ef49c82 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -37,19 +37,23 @@
     "non_data_affiliates",
 )
 
-agreement_patterns = (
+signed_agreement_patterns = (
     [
         path("", views.SignedAgreementList.as_view(), name="list"),
         path("members/", include(member_agreement_patterns)),
         path("data_affiliates/", include(data_affiliate_agreement_patterns)),
         path("non_data_affiliates/", include(non_data_affiliate_agreement_patterns)),
     ],
-    "agreements",
+    "signed_agreements",
 )
 
 audit_patterns = (
     [
-        path("agreements/", views.SignedAgreementAudit.as_view(), name="agreements"),
+        path(
+            "signed_agreements/",
+            views.SignedAgreementAudit.as_view(),
+            name="signed_agreements",
+        ),
         path("workspaces/", views.CDSAWorkspaceAudit.as_view(), name="workspaces"),
     ],
     "audit",
@@ -83,7 +87,7 @@
 
 
 urlpatterns = [
-    path("agreements/", include(agreement_patterns)),
+    path("signed_agreements/", include(signed_agreement_patterns)),
     path("records/", include(records_patterns)),
     path("audit/", include(audit_patterns)),
 ]
diff --git a/primed/templates/cdsa/nav_items.html b/primed/templates/cdsa/nav_items.html
index 9587b192..6779cfa0 100644
--- a/primed/templates/cdsa/nav_items.html
+++ b/primed/templates/cdsa/nav_items.html
@@ -3,39 +3,39 @@
     CDSA
   </a>
   <ul class="dropdown-menu dropdown-menu-dark" aria-labelledby="navbarDarkDropdownMenuLink">
-    <li class="dropdown-item"><b>List agreements</b></li>
+    <li class="dropdown-item"><b>List signed agreements</b></li>
     <li>
-      <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:list' %}">All</a>
+      <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:list' %}">All</a>
     </li>
     <li>
-      <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:members:list' %}">Members</a>
+      <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:members:list' %}">Members</a>
     </li>
     <li>
-      <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:data_affiliates:list' %}">Data affiliates</a>
+      <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:data_affiliates:list' %}">Data affiliates</a>
     </li>
     <li>
-      <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:non_data_affiliates:list' %}">Non-data affiliates</a>
+      <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:non_data_affiliates:list' %}">Non-data affiliates</a>
     </li>
 
     <li><hr class="dropdown-divider"></li>
 
     {% if perms.anvil_consortium_manager.anvil_project_manager_edit %}
-      <li class="dropdown-item"><b>Add a new agreement</b></li>
+      <li class="dropdown-item"><b>Add a new signed agreement</b></li>
       <li>
-        <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:members:new' %}">Member</a>
+        <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:members:new' %}">Member</a>
       </li>
       <li>
-        <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:data_affiliates:new' %}">Data affiliate</a>
+        <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:data_affiliates:new' %}">Data affiliate</a>
       </li>
       <li>
-        <a class="dropdown-item mx-3" href="{% url 'cdsa:agreements:non_data_affiliates:new' %}">Non-data affiliate</a>
+        <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:non_data_affiliates:new' %}">Non-data affiliate</a>
       </li>
 
       <li><hr class="dropdown-divider"></li>
     {% endif %}
 
     <li>
-      <a class="dropdown-item" href="{% url 'cdsa:audit:agreements'%}">Audit agreements</a>
+      <a class="dropdown-item" href="{% url 'cdsa:audit:signed_agreements'%}">Audit signed agreements</a>
     </li>
     <li>
       <a class="dropdown-item" href="{% url 'cdsa:audit:workspaces'%}">Audit workspaces</a>

From b815665e065ef114aece7557e15c8a47760b67c2 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 15:11:11 -0700
Subject: [PATCH 02/53] Add a detail view for an AgreementVersion

This view shows the set of signed agreements that exist with this
agreement version.
---
 primed/cdsa/tests/test_views.py               | 186 ++++++++++++++++++
 primed/cdsa/urls.py                           |  16 ++
 primed/cdsa/views.py                          |  38 +++-
 .../cdsa/agreementversion_detail.html         |  34 ++++
 4 files changed, 273 insertions(+), 1 deletion(-)
 create mode 100644 primed/templates/cdsa/agreementversion_detail.html

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 728a9476..4010793a 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -40,6 +40,192 @@
 User = get_user_model()
 
 
+class AgreementVersionDetailTest(TestCase):
+    """Tests for the AgreementVersionDetail view."""
+
+    def setUp(self):
+        """Set up test class."""
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permission.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        # Create an object test this with.
+        self.obj = factories.AgreementVersionFactory.create()
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:agreement_versions:detail", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.AgreementVersionDetail.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(2, 5))
+        self.assertRedirects(
+            response,
+            resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(2, 5),
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(2, 5))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, major_version=2, minor_version=5)
+
+    def test_view_status_code_with_existing_object(self):
+        """Returns a successful status code for an existing object pk."""
+        # Only clients load the template.
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+
+    def test_view_status_code_with_invalid_version(self):
+        """Raises a 404 error with an invalid major and minor version."""
+        request = self.factory.get(
+            self.get_url(self.obj.major_version + 1, self.obj.minor_version + 1)
+        )
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(
+                request,
+                major_version=self.obj.major_version + 1,
+                minor_version=self.obj.minor_version + 1,
+            )
+
+    def test_view_status_code_with_other_major_version(self):
+        """Raises a 404 error with an invalid object major version."""
+        other_agreement = factories.AgreementVersionFactory.create(
+            major_version=self.obj.major_version + 1,
+            minor_version=self.obj.minor_version,
+        )
+        request = self.factory.get(
+            self.get_url(
+                other_agreement.major_version + 1, other_agreement.minor_version
+            )
+        )
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(
+                request,
+                major_version=other_agreement.major_version + 1,
+                minor_version=other_agreement.minor_version,
+            )
+
+    def test_view_status_code_with_other_minor_version(self):
+        """Raises a 404 error with an invalid object minor version."""
+        other_agreement = factories.AgreementVersionFactory.create(
+            major_version=self.obj.major_version,
+            minor_version=self.obj.minor_version + 1,
+        )
+        request = self.factory.get(
+            self.get_url(
+                other_agreement.major_version, other_agreement.minor_version + 1
+            )
+        )
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(
+                request,
+                major_version=other_agreement.major_version,
+                minor_version=other_agreement.minor_version + 1,
+            )
+
+    # def test_response_includes_link_to_major_agreement(self):
+    #     """Response includes a link to the user profile page."""
+    #     self.client.force_login(self.user)
+    #     response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+    #     self.assertContains(
+    #         response, self.obj.signed_agreement.representative.get_absolute_url()
+    #     )
+
+    def test_response_includes_signed_agreement_table(self):
+        """Response includes a table of SignedAgreements."""
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("signed_agreement_table", response.context_data)
+        self.assertIsInstance(
+            response.context_data["signed_agreement_table"], tables.SignedAgreementTable
+        )
+
+    def test_response_signed_agreement_table_three_agreements(self):
+        """signed_agreement_table includes all types of agreements."""
+        member_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__version=self.obj
+        )
+        da_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version=self.obj
+        )
+        nda_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__version=self.obj
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context_data["signed_agreement_table"].rows), 3)
+        self.assertIn(
+            member_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+        self.assertIn(
+            da_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+        self.assertIn(
+            nda_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+
+    def test_response_signed_agreement_table_other_version(self):
+        """signed_agreement_table does not include agreements from other versions."""
+        member_agreement = factories.MemberAgreementFactory.create()
+        da_agreement = factories.DataAffiliateAgreementFactory.create()
+        nda_agreement = factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context_data["signed_agreement_table"].rows), 0)
+        self.assertNotIn(
+            member_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+        self.assertNotIn(
+            da_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+        self.assertNotIn(
+            nda_agreement.signed_agreement,
+            response.context_data["signed_agreement_table"].data,
+        )
+
+
 class SignedAgreementListTest(TestCase):
     """Tests for the SignedAgreementList view."""
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index 5ef49c82..77c594fd 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -4,6 +4,21 @@
 
 app_name = "cdsa"
 
+agreement_version_patterns = (
+    [
+        path(
+            "<int:major_version>",
+            views.AgreementMajorVersionDetail.as_view(),
+            name="major_version_detail",
+        ),
+        path(
+            "v<int:major_version>.<int:minor_version>",
+            views.AgreementVersionDetail.as_view(),
+            name="detail",
+        ),
+    ],
+    "agreement_versions",
+)
 member_agreement_patterns = (
     [
         path("", views.MemberAgreementList.as_view(), name="list"),
@@ -87,6 +102,7 @@
 
 
 urlpatterns = [
+    path("agreement_versions/", include(agreement_version_patterns)),
     path("signed_agreements/", include(signed_agreement_patterns)),
     path("records/", include(records_patterns)),
     path("audit/", include(audit_patterns)),
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index c3c16263..b24d46f0 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -14,8 +14,9 @@
 from django.forms import inlineformset_factory
 from django.http import Http404, HttpResponseRedirect
 from django.urls import reverse
+from django.utils.translation import ugettext_lazy as _
 from django.views.generic import DetailView, FormView, TemplateView
-from django_tables2 import SingleTableView
+from django_tables2 import MultiTableMixin, SingleTableMixin, SingleTableView
 
 from . import forms, helpers, models, tables
 from .audit import signed_agreement_audit, workspace_audit
@@ -23,6 +24,41 @@
 logger = logging.getLogger(__name__)
 
 
+class AgreementMajorVersionDetail(
+    AnVILConsortiumManagerViewRequired, MultiTableMixin, TemplateView
+):
+    """Display a "detail" page for an agreement major version (e.g., 1.x)."""
+
+
+class AgreementVersionDetail(
+    AnVILConsortiumManagerViewRequired, SingleTableMixin, DetailView
+):
+    """Display a "detail" page for an agreement major/minor version (e.g., 1.3)."""
+
+    model = models.AgreementVersion
+    table_class = tables.SignedAgreementTable
+    context_table_name = "signed_agreement_table"
+
+    def get_table_data(self):
+        qs = models.SignedAgreement.objects.filter(version=self.object)
+        # import ipdb; ipdb.set_trace()
+        print(qs)
+        return qs
+
+    def get_object(self, queryset=None):
+        queryset = self.model.objects.all()
+        try:
+            major_version = self.kwargs["major_version"]
+            minor_version = self.kwargs["minor_version"]
+            obj = queryset.get(major_version=major_version, minor_version=minor_version)
+        except (KeyError, self.model.DoesNotExist):
+            raise Http404(
+                _("No %(verbose_name)s found matching the query")
+                % {"verbose_name": queryset.model._meta.verbose_name}
+            )
+        return obj
+
+
 class SignedAgreementList(AnVILConsortiumManagerViewRequired, SingleTableView):
     """Display a list of SignedAgreement objects."""
 
diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
new file mode 100644
index 00000000..403cad5a
--- /dev/null
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -0,0 +1,34 @@
+{% extends "anvil_consortium_manager/__object_detail.html" %}
+{% load django_tables2 %}
+
+{% block title %}Agreement version {{ object }}{% endblock %}
+
+{% block panel %}
+<dl class="row">
+  <dt class="col-sm-2">Version</dt> <dd class="col-sm-9">{{ object.full_version }} (Major version {{ object.major_version }})</dd>
+  <dt class="col-sm-2">Date approved</dt> <dd class="col-sm-9">{{ object.date_approved }}</dd>
+</dl>
+{% endblock panel %}
+
+{% block after_panel %}
+
+<h3>Data access mechanisms</h3>
+
+<div class="accordion my-3" id="accordionSignedAgreements">
+  <div class="accordion-item">
+    <h2 class="accordion-header" id="signed-agreements-heading">
+      <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#signed-agreements-collapse" aria-expanded="false" aria-controls="signed-agreements-collapse">
+        <span class="fa-solid fa-computer mx-2"></span>
+        Signed agreements with this version
+        <span class="badge bg-{% if signed_agreement_table.rows|length %}primary{% else %}secondary{% endif %} mx-3"> {{signed_agreement_table.rows|length}} </span>
+      </button>
+    </h2>
+    <div id="signed-agreements-collapse" class="accordion-collapse collapse" aria-labelledby="signed-agreements-heading">
+      <div class="accordion-body">
+        {% render_table signed_agreement_table %}
+      </div>
+    </div>
+  </div>
+</div>
+
+{% endblock after_panel %}

From 459b4681cdfd28cb9a9adf8b93825509890a113a Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 15:16:07 -0700
Subject: [PATCH 03/53] Add a get_absolute_url method for an AgreementVersion

---
 primed/cdsa/models.py            | 9 +++++++++
 primed/cdsa/tests/test_models.py | 5 +++++
 2 files changed, 14 insertions(+)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index e30bbfd4..12df67bc 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -45,6 +45,15 @@ class Meta:
     def __str__(self):
         return self.full_version
 
+    def get_absolute_url(self):
+        return reverse(
+            "cdsa:agreement_versions:detail",
+            kwargs={
+                "major_version": self.major_version,
+                "minor_version": self.minor_version,
+            },
+        )
+
     @property
     def full_version(self):
         return "v{}.{}".format(self.major_version, self.minor_version)
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index dcd4a36d..ff9d263d 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -116,6 +116,11 @@ def test_str(self):
         instance = factories.AgreementVersionFactory.build()
         self.assertIsInstance(str(instance), str)
 
+    def test_get_absolute_url(self):
+        """get_absolute_url method works correctly."""
+        instance = factories.AgreementVersionFactory.create()
+        self.assertIsInstance(instance.get_absolute_url(), str)
+
 
 class SignedAgreementTest(TestCase):
     """Tests for the SignedAgreement model."""

From 9a20157198fd68ad92000ba9f06d88586253720d Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 15:21:56 -0700
Subject: [PATCH 04/53] Link to the AgreementVersion detail in signed agreement
 tables

---
 primed/cdsa/tables.py                                       | 4 ++++
 primed/templates/cdsa/dataaffiliateagreement_detail.html    | 4 +++-
 primed/templates/cdsa/memberagreement_detail.html           | 4 +++-
 primed/templates/cdsa/nondataaffiliateagreement_detail.html | 4 +++-
 4 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 579ce874..f17ee738 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -35,6 +35,7 @@ class SignedAgreementTable(tables.Table):
         if hasattr(record.agreement_group, "get_absolute_url")
         else None
     )
+    version = tables.Column(linkify=True)
 
     class Meta:
         model = models.SignedAgreement
@@ -66,6 +67,7 @@ class MemberAgreementTable(tables.Table):
         verbose_name="Number of accessors",
         accessor="signed_agreement__anvil_access_group__groupaccountmembership_set__count",
     )
+    signed_agreement__version = tables.Column(linkify=True)
 
     class Meta:
         model = models.MemberAgreement
@@ -97,6 +99,7 @@ class DataAffiliateAgreementTable(tables.Table):
         verbose_name="Number of accessors",
         accessor="signed_agreement__anvil_access_group__groupaccountmembership_set__count",
     )
+    signed_agreement__version = tables.Column(linkify=True)
 
     class Meta:
         model = models.DataAffiliateAgreement
@@ -127,6 +130,7 @@ class NonDataAffiliateAgreementTable(tables.Table):
         verbose_name="Number of accessors",
         accessor="signed_agreement__anvil_access_group__groupaccountmembership_set__count",
     )
+    signed_agreement__version = tables.Column(linkify=True)
 
     class Meta:
         model = models.NonDataAffiliateAgreement
diff --git a/primed/templates/cdsa/dataaffiliateagreement_detail.html b/primed/templates/cdsa/dataaffiliateagreement_detail.html
index 28d6f3f4..ab53eb35 100644
--- a/primed/templates/cdsa/dataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/dataaffiliateagreement_detail.html
@@ -12,7 +12,9 @@
   <dt class="col-sm-2">Representative role</dt> <dd class="col-sm-9">{{ object.signed_agreement.representative_role }}</dd>
   <dt class="col-sm-2">Signing institution</dt> <dd class="col-sm-9">{{ object.signed_agreement.signing_institution }}</dd>
   <dt class="col-sm-2">Primary?</dt> <dd class="col-sm-9">{{ object.signed_agreement.is_primary }}</dd>
-  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">{{ object.signed_agreement.version }}</dd>
+  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
+    <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
+  </dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Study</dt> <dd class="col-sm-9">
diff --git a/primed/templates/cdsa/memberagreement_detail.html b/primed/templates/cdsa/memberagreement_detail.html
index b2078efc..5c1b5d18 100644
--- a/primed/templates/cdsa/memberagreement_detail.html
+++ b/primed/templates/cdsa/memberagreement_detail.html
@@ -12,7 +12,9 @@
   <dt class="col-sm-2">Representative role</dt> <dd class="col-sm-9">{{ object.signed_agreement.representative_role }}</dd>
   <dt class="col-sm-2">Signing institution</dt> <dd class="col-sm-9">{{ object.signed_agreement.signing_institution }}</dd>
   <dt class="col-sm-2">Primary?</dt> <dd class="col-sm-9">{{ object.signed_agreement.is_primary }}</dd>
-  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">{{ object.signed_agreement.version }}</dd>
+  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
+    <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
+  </dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Study site</dt> <dd class="col-sm-9">
diff --git a/primed/templates/cdsa/nondataaffiliateagreement_detail.html b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
index ab4fd3df..b434ed02 100644
--- a/primed/templates/cdsa/nondataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
@@ -12,7 +12,9 @@
   <dt class="col-sm-2">Representative role</dt> <dd class="col-sm-9">{{ object.signed_agreement.representative_role }}</dd>
   <dt class="col-sm-2">Signing institution</dt> <dd class="col-sm-9">{{ object.signed_agreement.signing_institution }}</dd>
   <dt class="col-sm-2">Primary?</dt> <dd class="col-sm-9">{{ object.signed_agreement.is_primary }}</dd>
-  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">{{ object.signed_agreement.version }}</dd>
+  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
+    <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
+  </dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Affiliation</dt> <dd class="col-sm-9">{{ object.affiliation }}</dd>

From ec20d68dc35531201d1f4936f71a19382d98521e Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 15:24:59 -0700
Subject: [PATCH 05/53] Fix header in AgreementVersion detail template

---
 primed/templates/cdsa/agreementversion_detail.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
index 403cad5a..37a7a048 100644
--- a/primed/templates/cdsa/agreementversion_detail.html
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -12,7 +12,7 @@
 
 {% block after_panel %}
 
-<h3>Data access mechanisms</h3>
+<h3>Signed agreements</h3>
 
 <div class="accordion my-3" id="accordionSignedAgreements">
   <div class="accordion-item">

From 6ed59fe3fd54eb1c0c3e4dc82c7b1c9946906f23 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 15:37:59 -0700
Subject: [PATCH 06/53] Add a view to list AgreementVersions

Add a table for AgreementVersion as well as a detail view and a url.
Add a link in the navbar to this view.
---
 primed/cdsa/tables.py                         | 17 +++++
 primed/cdsa/tests/test_tables.py              | 20 ++++++
 primed/cdsa/tests/test_views.py               | 72 +++++++++++++++++++
 primed/cdsa/urls.py                           |  5 ++
 primed/cdsa/views.py                          |  7 ++
 .../templates/cdsa/agreementversion_list.html | 11 +++
 primed/templates/cdsa/nav_items.html          |  6 ++
 7 files changed, 138 insertions(+)
 create mode 100644 primed/templates/cdsa/agreementversion_list.html

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index f17ee738..0c474a00 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -15,6 +15,23 @@
 from . import models
 
 
+class AgreementVersionTable(tables.Table):
+
+    full_version = tables.Column(
+        linkify=True, order_by=("major_version", "minor_version")
+    )
+    major_version = tables.Column()
+
+    class Meta:
+        model = models.AgreementVersion
+        fields = (
+            "full_version",
+            "major_version",
+            "minor_version",
+            "date_approved",
+        )
+
+
 class SignedAgreementTable(tables.Table):
 
     cc_id = tables.Column(linkify=True)
diff --git a/primed/cdsa/tests/test_tables.py b/primed/cdsa/tests/test_tables.py
index 37f467b6..2c79ac62 100644
--- a/primed/cdsa/tests/test_tables.py
+++ b/primed/cdsa/tests/test_tables.py
@@ -13,6 +13,26 @@
 from . import factories
 
 
+class AgreementVersionTableTest(TestCase):
+    model = models.AgreementVersion
+    model_factory = factories.AgreementVersionFactory
+    table_class = tables.AgreementVersionTable
+
+    def test_row_count_with_no_objects(self):
+        table = self.table_class(self.model.objects.all())
+        self.assertEqual(len(table.rows), 0)
+
+    def test_row_count_with_one_object(self):
+        self.model_factory.create()
+        table = self.table_class(self.model.objects.all())
+        self.assertEqual(len(table.rows), 1)
+
+    def test_row_count_with_three_objects(self):
+        self.model_factory.create_batch(3)
+        table = self.table_class(self.model.objects.all())
+        self.assertEqual(len(table.rows), 3)
+
+
 class SignedAgreementTableTest(TestCase):
     model = models.SignedAgreement
     table_class = tables.SignedAgreementTable
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 4010793a..b1d29d17 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -40,6 +40,78 @@
 User = get_user_model()
 
 
+class AgreementVersionListTest(TestCase):
+    """Tests for the AgreementVersionList view."""
+
+    def setUp(self):
+        """Set up test class."""
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permission.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:agreement_versions:list", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.AgreementVersionList.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url())
+        self.assertRedirects(
+            response,
+            resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(),
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url())
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request)
+
+    def test_table_class(self):
+        """The table is the correct class."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        self.assertIsInstance(
+            response.context_data["table"], tables.AgreementVersionTable
+        )
+
+    def test_workspace_table_none(self):
+        """No rows are shown if there are no AgreementVersion objects."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        self.assertEqual(len(response.context_data["table"].rows), 0)
+
+    def test_workspace_table_three(self):
+        """Two rows are shown if there are three AgreementVersion objects."""
+        factories.AgreementVersionFactory.create_batch(3)
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        self.assertEqual(len(response.context_data["table"].rows), 3)
+
+
 class AgreementVersionDetailTest(TestCase):
     """Tests for the AgreementVersionDetail view."""
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index 77c594fd..01802b42 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -6,6 +6,11 @@
 
 agreement_version_patterns = (
     [
+        path(
+            "",
+            views.AgreementVersionList.as_view(),
+            name="list",
+        ),
         path(
             "<int:major_version>",
             views.AgreementMajorVersionDetail.as_view(),
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index b24d46f0..d5bd17a1 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -59,6 +59,13 @@ def get_object(self, queryset=None):
         return obj
 
 
+class AgreementVersionList(AnVILConsortiumManagerViewRequired, SingleTableView):
+    """Display a list of AgreementVersions."""
+
+    model = models.AgreementVersion
+    table_class = tables.AgreementVersionTable
+
+
 class SignedAgreementList(AnVILConsortiumManagerViewRequired, SingleTableView):
     """Display a list of SignedAgreement objects."""
 
diff --git a/primed/templates/cdsa/agreementversion_list.html b/primed/templates/cdsa/agreementversion_list.html
new file mode 100644
index 00000000..f3e5d85f
--- /dev/null
+++ b/primed/templates/cdsa/agreementversion_list.html
@@ -0,0 +1,11 @@
+{% extends "anvil_consortium_manager/base.html" %}
+{% load render_table from django_tables2 %}
+
+{% block title %}Agreement Versions{% endblock %}
+
+{% block content %}
+<h1>Agreement Versions</h1>
+
+{% render_table table %}
+
+{% endblock content %}
diff --git a/primed/templates/cdsa/nav_items.html b/primed/templates/cdsa/nav_items.html
index 6779cfa0..13e26408 100644
--- a/primed/templates/cdsa/nav_items.html
+++ b/primed/templates/cdsa/nav_items.html
@@ -3,6 +3,12 @@
     CDSA
   </a>
   <ul class="dropdown-menu dropdown-menu-dark" aria-labelledby="navbarDarkDropdownMenuLink">
+
+    <li>
+      <a class="dropdown-item" href="{% url 'cdsa:agreement_versions:list'%}">List agreement versions</a>
+    </li>
+    <li><hr class="dropdown-divider"></li>
+
     <li class="dropdown-item"><b>List signed agreements</b></li>
     <li>
       <a class="dropdown-item mx-3" href="{% url 'cdsa:signed_agreements:list' %}">All</a>

From 403d4716a08334676f56ccab0d88712b2f3923f7 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 16:07:21 -0700
Subject: [PATCH 07/53] Add a "detail" view for an agreement major version

This is not a true detail view, but displays information about
the major_version associated with one or more agreement_versions.
Add a url, a view, a template, and tests.
---
 primed/cdsa/tests/test_views.py               | 134 ++++++++++++++++++
 primed/cdsa/urls.py                           |   4 +-
 primed/cdsa/views.py                          |  30 ++++
 .../cdsa/agreementmajorversion_detail.html    |  52 +++++++
 4 files changed, 218 insertions(+), 2 deletions(-)
 create mode 100644 primed/templates/cdsa/agreementmajorversion_detail.html

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index b1d29d17..d7063a98 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -112,6 +112,140 @@ def test_workspace_table_three(self):
         self.assertEqual(len(response.context_data["table"].rows), 3)
 
 
+class AgreementMajorVersionDetailTest(TestCase):
+    """Tests for the AgreementVersionDetail view."""
+
+    def setUp(self):
+        """Set up test class."""
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permission.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        # Create an object test this with.
+        self.obj = factories.AgreementVersionFactory.create()
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:agreement_versions:major_version_detail", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.AgreementMajorVersionDetail.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(2))
+        self.assertRedirects(
+            response,
+            resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(2),
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(2))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, major_version=2)
+
+    def test_view_status_code_with_existing_object(self):
+        """Returns a successful status code for an existing object pk."""
+        # Only clients load the template.
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+
+    def test_view_status_code_with_invalid_version(self):
+        """Raises a 404 error with an invalid major and minor version."""
+        request = self.factory.get(self.get_url(self.obj.major_version + 1))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(
+                request,
+                major_version=self.obj.major_version + 1,
+            )
+
+    def test_context_major_version(self):
+        """Context includes major_version."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("major_version", response.context_data)
+        self.assertEqual(response.context_data["major_version"], self.obj.major_version)
+
+    def test_context_table_classes(self):
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("tables", response.context_data)
+        self.assertEqual(len(response.context_data["tables"]), 2)
+        self.assertIsInstance(
+            response.context_data["tables"][0], tables.AgreementVersionTable
+        )
+        self.assertIsInstance(
+            response.context_data["tables"][1], tables.SignedAgreementTable
+        )
+
+    def test_response_includes_agreement_version_table(self):
+        """agreement_version_table includes agreement_versions with this major version."""
+        factories.AgreementVersionFactory.create(major_version=self.obj.major_version)
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        # 2 - one for the object we created in the setup method, one for the new object in this test.
+        self.assertEqual(len(response.context_data["tables"][0].rows), 2)
+
+    def test_response_includes_agreement_version_table_other_major_version(self):
+        """agreement_version_table includes only agreement_versions with this major version."""
+        other_agreement = factories.AgreementVersionFactory.create(
+            major_version=self.obj.major_version + 1
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        # 2 - one for the object we created in the setup method, one for the new object in this test.
+        self.assertEqual(len(response.context_data["tables"][0].rows), 1)
+        self.assertIn(self.obj, response.context_data["tables"][0].data)
+        self.assertNotIn(other_agreement, response.context_data["tables"][0].data)
+
+    def test_response_signed_agreement_table_three_agreements(self):
+        """signed_agreement_table includes all types of agreements."""
+        factories.MemberAgreementFactory.create(
+            signed_agreement__version__major_version=self.obj.major_version
+        )
+        factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version=self.obj.major_version
+        )
+        factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version=self.obj.major_version
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context_data["tables"][1].rows), 3)
+
+    def test_response_signed_agreement_table_other_major_version(self):
+        """signed_agreement_table does not include agreements from other versions."""
+        factories.MemberAgreementFactory.create()
+        factories.DataAffiliateAgreementFactory.create()
+        factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.major_version))
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.context_data["tables"][1].rows), 0)
+
+
 class AgreementVersionDetailTest(TestCase):
     """Tests for the AgreementVersionDetail view."""
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index 01802b42..e1b05873 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -12,12 +12,12 @@
             name="list",
         ),
         path(
-            "<int:major_version>",
+            "v<int:major_version>/",
             views.AgreementMajorVersionDetail.as_view(),
             name="major_version_detail",
         ),
         path(
-            "v<int:major_version>.<int:minor_version>",
+            "v<int:major_version>.<int:minor_version>/",
             views.AgreementVersionDetail.as_view(),
             name="detail",
         ),
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index d5bd17a1..4cf0839a 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -29,6 +29,36 @@ class AgreementMajorVersionDetail(
 ):
     """Display a "detail" page for an agreement major version (e.g., 1.x)."""
 
+    template_name = "cdsa/agreementmajorversion_detail.html"
+    tables = (tables.AgreementVersionTable, tables.SignedAgreementTable)
+
+    def get_major_version(self):
+        major_version = self.kwargs.get("major_version")
+        qs = models.AgreementVersion.objects.filter(major_version=major_version)
+        if not qs.count():
+            raise Http404(
+                _("No AgreementVersions with major_version found matching the query")
+            )
+        return major_version
+
+    def get(self, request, *args, **kwargs):
+        self.major_version = self.get_major_version()
+        return super().get(request, *args, **kwargs)
+
+    def get_tables_data(self):
+        agreement_version_qs = models.AgreementVersion.objects.filter(
+            major_version=self.major_version
+        )
+        signed_agreement_qs = models.SignedAgreement.objects.filter(
+            version__major_version=self.major_version
+        )
+        return [agreement_version_qs, signed_agreement_qs]
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data()
+        context["major_version"] = self.major_version
+        return context
+
 
 class AgreementVersionDetail(
     AnVILConsortiumManagerViewRequired, SingleTableMixin, DetailView
diff --git a/primed/templates/cdsa/agreementmajorversion_detail.html b/primed/templates/cdsa/agreementmajorversion_detail.html
new file mode 100644
index 00000000..e306464e
--- /dev/null
+++ b/primed/templates/cdsa/agreementmajorversion_detail.html
@@ -0,0 +1,52 @@
+{% extends "anvil_consortium_manager/__object_detail.html" %}
+{% load django_tables2 %}
+
+{% block title %}Agreement version v{{ major_version }}{% endblock %}
+
+{% block panel %}
+<dl class="row">
+  <dt class="col-sm-2">Version</dt> <dd class="col-sm-9"> v{{ major_version }}</dd>
+</dl>
+{% endblock panel %}
+
+{% block after_panel %}
+
+<h3>Agreement versions</h3>
+
+<div class="accordion my-3" id="accordionAgreementVersions">
+  <div class="accordion-item">
+    <h2 class="accordion-header" id="agreements-versions-heading">
+      <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#agreements-versions-collapse" aria-expanded="false" aria-controls="signed-agreements-collapse">
+        <span class="fa-solid fa-computer mx-2"></span>
+        Signed agreements with this version
+        <span class="badge bg-{% if tables.0.rows|length %}primary{% else %}secondary{% endif %} mx-3"> {{tables.0.rows|length}} </span>
+      </button>
+    </h2>
+    <div id="agreements-versions-collapse" class="accordion-collapse collapse" aria-labelledby="agreements-versions-heading">
+      <div class="accordion-body">
+        {% render_table tables.0 %}
+      </div>
+    </div>
+  </div>
+</div>
+
+<h3>Signed agreements</h3>
+
+<div class="accordion my-3" id="accordionSignedAgreements">
+  <div class="accordion-item">
+    <h2 class="accordion-header" id="signed-agreements-heading">
+      <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#signed-agreements-collapse" aria-expanded="false" aria-controls="signed-agreements-collapse">
+        <span class="fa-solid fa-computer mx-2"></span>
+        Signed agreements with this version
+        <span class="badge bg-{% if tables.1.rows|length %}primary{% else %}secondary{% endif %} mx-3"> {{tables.1.rows|length}} </span>
+      </button>
+    </h2>
+    <div id="signed-agreements-collapse" class="accordion-collapse collapse" aria-labelledby="signed-agreements-heading">
+      <div class="accordion-body">
+        {% render_table tables.1 %}
+      </div>
+    </div>
+  </div>
+</div>
+
+{% endblock after_panel %}

From 2b0d1d01b615879d802a0d893be23b24b361e482 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 30 Aug 2023 16:15:10 -0700
Subject: [PATCH 08/53] Link to the agreement major version "detail" where
 appropriate

Add a get_major_version_absolute_url method to AgreementVersion.
Link to this url in relevant tables and detail pages.
---
 primed/cdsa/models.py                              |  8 ++++++++
 primed/cdsa/tables.py                              | 10 +++++++---
 primed/cdsa/tests/test_models.py                   |  5 +++++
 primed/templates/cdsa/agreementversion_detail.html |  6 +++++-
 4 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 12df67bc..0b026830 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -54,6 +54,14 @@ def get_absolute_url(self):
             },
         )
 
+    def get_major_version_absolute_url(self):
+        return reverse(
+            "cdsa:agreement_versions:major_version_detail",
+            kwargs={
+                "major_version": self.major_version,
+            },
+        )
+
     @property
     def full_version(self):
         return "v{}.{}".format(self.major_version, self.minor_version)
diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 0c474a00..dbebe71b 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -17,20 +17,24 @@
 
 class AgreementVersionTable(tables.Table):
 
+    major_version = tables.Column(
+        linkify=lambda record: record.get_major_version_absolute_url()
+    )
     full_version = tables.Column(
         linkify=True, order_by=("major_version", "minor_version")
     )
-    major_version = tables.Column()
 
     class Meta:
         model = models.AgreementVersion
         fields = (
-            "full_version",
             "major_version",
-            "minor_version",
+            "full_version",
             "date_approved",
         )
 
+    def render_major_version(self, record):
+        return "v{}".format(record.major_version)
+
 
 class SignedAgreementTable(tables.Table):
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index ff9d263d..6f6d6e8f 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -121,6 +121,11 @@ def test_get_absolute_url(self):
         instance = factories.AgreementVersionFactory.create()
         self.assertIsInstance(instance.get_absolute_url(), str)
 
+    def test_get_major_version_absolute_url(self):
+        """test_get_major_version_absolute_url method works correctly."""
+        instance = factories.AgreementVersionFactory.create()
+        self.assertIsInstance(instance.get_major_version_absolute_url(), str)
+
 
 class SignedAgreementTest(TestCase):
     """Tests for the SignedAgreement model."""
diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
index 37a7a048..b4ea8007 100644
--- a/primed/templates/cdsa/agreementversion_detail.html
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -5,7 +5,11 @@
 
 {% block panel %}
 <dl class="row">
-  <dt class="col-sm-2">Version</dt> <dd class="col-sm-9">{{ object.full_version }} (Major version {{ object.major_version }})</dd>
+  <dt class="col-sm-2">Full version</dt> <dd class="col-sm-9">{{ object.full_version }}</dd>
+  <dt class="col-sm-2">Major version</dt> <dd class="col-sm-9">
+    <a href="{{ object.get_major_version_absolute_url }}">v{{ object.major_version }}</a>
+  </dd>
+
   <dt class="col-sm-2">Date approved</dt> <dd class="col-sm-9">{{ object.date_approved }}</dd>
 </dl>
 {% endblock panel %}

From 617e6691aac10cba2446acc76e36f08c83982c43 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 09:27:08 -0700
Subject: [PATCH 09/53] Remove cc_id from records table

---
 primed/cdsa/tables.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index dbebe71b..87631427 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -179,7 +179,6 @@ class RepresentativeRecordsTable(tables.Table):
     class Meta:
         model = models.SignedAgreement
         fields = (
-            "cc_id",
             "representative__name",
             "representative_role",
             "signing_institution",

From 90c6b3d8d67bde55b03950963b1a1afb52d9762a Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 11:33:35 -0700
Subject: [PATCH 10/53] Add a model for AgreementMajorVersion

Add a model definition, a factory, and tests. This model will be
used as a foreign key in AgreementVersion.
---
 ...version_historicalagreementmajorversion.py | 53 +++++++++++++++++++
 primed/cdsa/models.py                         | 22 ++++++++
 primed/cdsa/tests/factories.py                |  9 ++++
 primed/cdsa/tests/test_models.py              | 51 ++++++++++++++++++
 4 files changed, 135 insertions(+)
 create mode 100644 primed/cdsa/migrations/0002_agreementmajorversion_historicalagreementmajorversion.py

diff --git a/primed/cdsa/migrations/0002_agreementmajorversion_historicalagreementmajorversion.py b/primed/cdsa/migrations/0002_agreementmajorversion_historicalagreementmajorversion.py
new file mode 100644
index 00000000..a23e069b
--- /dev/null
+++ b/primed/cdsa/migrations/0002_agreementmajorversion_historicalagreementmajorversion.py
@@ -0,0 +1,53 @@
+# Generated by Django 3.2.19 on 2023-08-31 18:41
+
+from django.conf import settings
+import django.core.validators
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import simple_history.models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('cdsa', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AgreementMajorVersion',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', django_extensions.db.fields.CreationDateTimeField(auto_now_add=True, verbose_name='created')),
+                ('modified', django_extensions.db.fields.ModificationDateTimeField(auto_now=True, verbose_name='modified')),
+                ('version', models.IntegerField(help_text='Major version of the CDSA. Changes to the major version require resigning.', unique=True, validators=[django.core.validators.MinValueValidator(1)])),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='HistoricalAgreementMajorVersion',
+            fields=[
+                ('id', models.BigIntegerField(auto_created=True, blank=True, db_index=True, verbose_name='ID')),
+                ('created', django_extensions.db.fields.CreationDateTimeField(auto_now_add=True, verbose_name='created')),
+                ('modified', django_extensions.db.fields.ModificationDateTimeField(auto_now=True, verbose_name='modified')),
+                ('version', models.IntegerField(db_index=True, help_text='Major version of the CDSA. Changes to the major version require resigning.', validators=[django.core.validators.MinValueValidator(1)])),
+                ('history_id', models.AutoField(primary_key=True, serialize=False)),
+                ('history_date', models.DateTimeField(db_index=True)),
+                ('history_change_reason', models.CharField(max_length=100, null=True)),
+                ('history_type', models.CharField(choices=[('+', 'Created'), ('~', 'Changed'), ('-', 'Deleted')], max_length=1)),
+                ('history_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'historical agreement major version',
+                'verbose_name_plural': 'historical agreement major versions',
+                'ordering': ('-history_date', '-history_id'),
+                'get_latest_by': ('history_date', 'history_id'),
+            },
+            bases=(simple_history.models.HistoricalChanges, models.Model),
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 0b026830..3e574f65 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -15,6 +15,24 @@
 from primed.primed_anvil.models import AvailableData, RequesterModel, Study, StudySite
 
 
+class AgreementMajorVersion(TimeStampedModel, models.Model):
+    """A model for a major agreement version."""
+
+    version = models.IntegerField(
+        help_text="Major version of the CDSA. Changes to the major version require resigning.",
+        validators=[MinValueValidator(1)],
+        unique=True,
+    )
+
+    history = HistoricalRecords()
+
+    def __str__(self):
+        return "v{}".format(self.version)
+
+    # def get_absolute_url(self):
+    #     pass
+
+
 class AgreementVersion(TimeStampedModel, models.Model):
     """Model to track approved CDSA versions."""
 
@@ -66,6 +84,10 @@ def get_major_version_absolute_url(self):
     def full_version(self):
         return "v{}.{}".format(self.major_version, self.minor_version)
 
+    @property
+    def is_valid(self):
+        return True
+
 
 class SignedAgreement(TimeStampedModel, models.Model):
     """Model to track verified, signed consortium data sharing agreements."""
diff --git a/primed/cdsa/tests/factories.py b/primed/cdsa/tests/factories.py
index e84ac6d5..1c8a81ea 100644
--- a/primed/cdsa/tests/factories.py
+++ b/primed/cdsa/tests/factories.py
@@ -14,6 +14,15 @@
 from .. import models
 
 
+class AgreementMajorVersionFactory(DjangoModelFactory):
+    """A factory for the AgreementMajorVersion model."""
+
+    class Meta:
+        model = models.AgreementMajorVersion
+
+    version = Faker("random_int", min=1)
+
+
 class AgreementVersionFactory(DjangoModelFactory):
     """A factory for the AgreementVersion model."""
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 6f6d6e8f..1f42d65b 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -23,6 +23,57 @@
 from . import factories
 
 
+class AgreementMajorVersionTest(TestCase):
+    """Tests for the AgreementMajorVersion model."""
+
+    def test_model_saving(self):
+        instance = models.AgreementMajorVersion(version=1)
+        instance.save()
+        self.assertIsInstance(instance, models.AgreementMajorVersion)
+
+    def test_unique(self):
+        factories.AgreementMajorVersionFactory.create(version=1)
+        instance = factories.AgreementMajorVersionFactory.build(version=1)
+        with self.assertRaisesMessage(ValidationError, "already exists"):
+            instance.full_clean()
+        with self.assertRaises(IntegrityError):
+            instance.save()
+
+    def test_version_zero(self):
+        """ValidationError raised when version is zero."""
+        instance = factories.AgreementMajorVersionFactory.build(version=0)
+        with self.assertRaises(ValidationError) as e:
+            instance.full_clean()
+        self.assertEqual(len(e.exception.message_dict), 1)
+        self.assertIn("version", e.exception.message_dict)
+        self.assertEqual(len(e.exception.message_dict["version"]), 1)
+        self.assertIn(
+            "greater than or equal to", e.exception.message_dict["version"][0]
+        )
+
+    def test_version_negative(self):
+        """ValidationError raised when version is negative."""
+        instance = factories.AgreementMajorVersionFactory.build(version=-1)
+        with self.assertRaises(ValidationError) as e:
+            instance.full_clean()
+        self.assertEqual(len(e.exception.message_dict), 1)
+        self.assertIn("version", e.exception.message_dict)
+        self.assertEqual(len(e.exception.message_dict["version"]), 1)
+        self.assertIn(
+            "greater than or equal to", e.exception.message_dict["version"][0]
+        )
+
+    def test_str(self):
+        """__str__ method works as expected."""
+        instance = factories.AgreementMajorVersionFactory.build()
+        self.assertIsInstance(str(instance), str)
+
+    # def test_get_absolute_url(self):
+    #     """get_absolute_url method works correctly."""
+    #     instance = factories.AgreementMajorVersionFactory.create()
+    #     self.assertIsInstance(instance.get_absolute_url(), str)
+
+
 class AgreementVersionTest(TestCase):
     """Tests for the AgreementVersion model."""
 

From 9eb3b42f5da3966467760a1832aa2620b5d81abe Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 11:55:58 -0700
Subject: [PATCH 11/53] Add a nullable major_version_fk to the AgreementVersion
 model

This fk will be populated in a following data migration using the
values in major_version.
---
 ...3_agreementversion_add_major_version_fk.py | 24 +++++++++++++++++++
 primed/cdsa/models.py                         |  7 ++++++
 2 files changed, 31 insertions(+)
 create mode 100644 primed/cdsa/migrations/0003_agreementversion_add_major_version_fk.py

diff --git a/primed/cdsa/migrations/0003_agreementversion_add_major_version_fk.py b/primed/cdsa/migrations/0003_agreementversion_add_major_version_fk.py
new file mode 100644
index 00000000..e96af1f0
--- /dev/null
+++ b/primed/cdsa/migrations/0003_agreementversion_add_major_version_fk.py
@@ -0,0 +1,24 @@
+# Generated by Django 3.2.19 on 2023-08-31 18:53
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0002_agreementmajorversion_historicalagreementmajorversion'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='agreementversion',
+            name='major_version_fk',
+            field=models.ForeignKey(blank=True, help_text='Major version of the CDSA. Changes to the major version require resigning.', null=True, on_delete=django.db.models.deletion.CASCADE, to='cdsa.agreementmajorversion'),
+        ),
+        migrations.AddField(
+            model_name='historicalagreementversion',
+            name='major_version_fk',
+            field=models.ForeignKey(blank=True, db_constraint=False, help_text='Major version of the CDSA. Changes to the major version require resigning.', null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='cdsa.agreementmajorversion'),
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 3e574f65..0d2396c8 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -40,6 +40,13 @@ class AgreementVersion(TimeStampedModel, models.Model):
         help_text="Major version of the CDSA. Changes to the major version require resigning.",
         validators=[MinValueValidator(1)],
     )
+    major_version_fk = models.ForeignKey(
+        AgreementMajorVersion,
+        help_text="Major version of the CDSA. Changes to the major version require resigning.",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+    )
     minor_version = models.IntegerField(
         help_text="Minor version of the CDSA. Changes to the minor version do not require resigning.",
         validators=[MinValueValidator(0)],

From c98c9de049862f32d7d66a45df0c592f6d94b9c0 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 15:50:24 -0700
Subject: [PATCH 12/53] Add a data migration to populate AgreementMajorVersion
 and fk

This data migration does two things:
1. Create an AgreementMajorVersion record for each unique major_version
   in AgreementVersion.
2. Set major_version_fk to the appropriate AgreementMajorVersion
   instance for each AgreementVersion instance.

Also add tests for the migration. Add the django-test-migrations
package to the requirements file for local development, since it
is used in tests.
---
 .../0004_populate_agreementmajorversion.py    | 34 +++++++
 primed/cdsa/tests/test_migrations.py          | 95 +++++++++++++++++++
 requirements/local.txt                        |  4 +
 3 files changed, 133 insertions(+)
 create mode 100644 primed/cdsa/migrations/0004_populate_agreementmajorversion.py
 create mode 100644 primed/cdsa/tests/test_migrations.py

diff --git a/primed/cdsa/migrations/0004_populate_agreementmajorversion.py b/primed/cdsa/migrations/0004_populate_agreementmajorversion.py
new file mode 100644
index 00000000..9c88b576
--- /dev/null
+++ b/primed/cdsa/migrations/0004_populate_agreementmajorversion.py
@@ -0,0 +1,34 @@
+# Generated by Django 3.2.19 on 2023-08-31 18:58
+
+from django.db import migrations
+
+
+def populate_agreementversion_major_version_fk(apps, schema_editor):
+    """Populate the AgreementMajorVersion model using major_versions in AgreementVersion,
+    and set AgreementVersion.major_version_fk."""
+    AgreementVersion = apps.get_model("cdsa", "AgreementVersion")
+    AgreementMajorVersion = apps.get_model("cdsa", "AgreementMajorVersion")
+    for row in AgreementVersion.objects.all():
+        # Get or create the AgreementMajorVersion object.
+        try:
+            major_version = AgreementMajorVersion.objects.get(version=row.major_version)
+        except AgreementMajorVersion.DoesNotExist:
+            major_version = AgreementMajorVersion(
+                version=row.major_version,
+            )
+            major_version.full_clean()
+            major_version.save()
+        # Set major_version_fk for the agreement_version object.
+        row.major_version_fk = major_version
+        row.save(update_fields=["major_version_fk"])
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0003_agreementversion_add_major_version_fk'),
+    ]
+
+    operations = [
+        migrations.RunPython(populate_agreementversion_major_version_fk, reverse_code=migrations.RunPython.noop),
+    ]
diff --git a/primed/cdsa/tests/test_migrations.py b/primed/cdsa/tests/test_migrations.py
new file mode 100644
index 00000000..708e687f
--- /dev/null
+++ b/primed/cdsa/tests/test_migrations.py
@@ -0,0 +1,95 @@
+"""Tests for data migrations in the app."""
+from datetime import date
+
+from anvil_consortium_manager.tests.factories import BillingProjectFactory, WorkspaceFactory
+from django_test_migrations.contrib.unittest_case import MigratorTestCase
+import factory
+
+from . import factories
+
+class PopulateAgreementMajorVersionTest(MigratorTestCase):
+    """Tests for the populate_agreement_major_version migration."""
+
+    migrate_from = ("cdsa", "0003_agreementversion_add_major_version_fk")
+    migrate_to = ("cdsa", "0004_populate_agreementmajorversion")
+
+    def prepare(self):
+        """Prepare some data before the migration."""
+        # Get model definition for the old state.
+        AgreementVersion = self.old_state.apps.get_model("cdsa", "AgreementVersion")
+        # Populate with multiple major versions and minor versions.
+        self.agreement_version_1_0 = AgreementVersion.objects.create(
+            major_version=1,
+            minor_version=0,
+        )
+        self.agreement_version_1_1 = AgreementVersion.objects.create(
+            major_version=1,
+            minor_version=1,
+        )
+        self.agreement_version_1_2 = AgreementVersion.objects.create(
+            major_version=1,
+            minor_version=2,
+        )
+        self.agreement_version_2_1 = AgreementVersion.objects.create(
+            major_version=2,
+            minor_version=1,
+        )
+        self.agreement_version_2_3 = AgreementVersion.objects.create(
+            major_version=2,
+            minor_version=3,
+        )
+        self.agreement_version_3_0 = AgreementVersion.objects.create(
+            major_version=3,
+            minor_version=0,
+        )
+        self.agreement_version_5_6 = AgreementVersion.objects.create(
+            major_version=5,
+            minor_version=6,
+        )
+
+    def test_agreementmajorversion_model_correctly_populated(self):
+        """AgreementMajorVersion is correctly populated."""
+        AgreementMajorVersion = self.new_state.apps.get_model("cdsa", "AgreementMajorVersion")
+        self.assertEqual(AgreementMajorVersion.objects.count(), 4)
+        major_version = AgreementMajorVersion.objects.get(version=1)
+        major_version.full_clean()
+        major_version = AgreementMajorVersion.objects.get(version=2)
+        major_version.full_clean()
+        major_version = AgreementMajorVersion.objects.get(version=3)
+        major_version.full_clean()
+        major_version = AgreementMajorVersion.objects.get(version=5)
+        major_version.full_clean()
+
+    def test_agreement_version_major_version_fk_correctly_populated(self):
+        """AgreementVersion.major_version_fk is correctly populated."""
+        AgreementMajorVersion = self.new_state.apps.get_model("cdsa", "AgreementMajorVersion")
+        AgreementVersion = self.new_state.apps.get_model("cdsa", "AgreementVersion")
+        # Major version 1.
+        major_version = AgreementMajorVersion.objects.get(version=1)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_0.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 0)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_1.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 1)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_2.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 2)
+        # Major version 2.
+        major_version = AgreementMajorVersion.objects.get(version=2)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_2_1.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 1)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_2_3.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 3)
+        # Major version 3.
+        major_version = AgreementMajorVersion.objects.get(version=3)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_3_0.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 0)
+        # Major version 5.
+        major_version = AgreementMajorVersion.objects.get(version=5)
+        agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_5_6.pk)
+        self.assertEqual(agreement_version.major_version_fk, major_version)
+        self.assertEqual(agreement_version.minor_version, 6)
diff --git a/requirements/local.txt b/requirements/local.txt
index bfb8f45f..8a8b742d 100644
--- a/requirements/local.txt
+++ b/requirements/local.txt
@@ -37,3 +37,7 @@ setuptools==65.5.1 # https://github.com/pypa/setuptools
 django-debug-toolbar==3.4.0  # https://github.com/jazzband/django-debug-toolbar
 django-coverage-plugin==2.0.3  # https://github.com/nedbat/django_coverage_plugin
 pytest-django==4.5.2  # https://github.com/pytest-dev/pytest-django
+
+# Other additions
+# ------------------------------------------------------------------------------
+django-test-migrations==1.3.0

From c4f20ef6afc908435b611d095b788aab9beebf09 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:01:42 -0700
Subject: [PATCH 13/53] Replace existing major_version field with the new
 foreign key

Remove the previous major_version field and rename the temporary
major_version_fk field to major_version. Note that a lot of the code
will be broken since we didn't udpate any of it yet for these changes.
Rename the constraint, since mysql/mariadb will likely complain if
we don't.
---
 ...ementversion_remove_field_major_version.py | 29 +++++++++++++++++
 ...ename_major_version_fk_to_major_version.py | 31 +++++++++++++++++++
 primed/cdsa/models.py                         | 10 ++----
 3 files changed, 63 insertions(+), 7 deletions(-)
 create mode 100644 primed/cdsa/migrations/0005_agreementversion_remove_field_major_version.py
 create mode 100644 primed/cdsa/migrations/0006_agreementversion_rename_major_version_fk_to_major_version.py

diff --git a/primed/cdsa/migrations/0005_agreementversion_remove_field_major_version.py b/primed/cdsa/migrations/0005_agreementversion_remove_field_major_version.py
new file mode 100644
index 00000000..352c471e
--- /dev/null
+++ b/primed/cdsa/migrations/0005_agreementversion_remove_field_major_version.py
@@ -0,0 +1,29 @@
+# Generated by Django 3.2.19 on 2023-08-31 22:55
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0004_populate_agreementmajorversion'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='agreementversion',
+            options={'get_latest_by': 'modified'},
+        ),
+        migrations.RemoveConstraint(
+            model_name='agreementversion',
+            name='unique_agreement_version',
+        ),
+        migrations.RemoveField(
+            model_name='agreementversion',
+            name='major_version',
+        ),
+        migrations.RemoveField(
+            model_name='historicalagreementversion',
+            name='major_version',
+        ),
+    ]
diff --git a/primed/cdsa/migrations/0006_agreementversion_rename_major_version_fk_to_major_version.py b/primed/cdsa/migrations/0006_agreementversion_rename_major_version_fk_to_major_version.py
new file mode 100644
index 00000000..712457c3
--- /dev/null
+++ b/primed/cdsa/migrations/0006_agreementversion_rename_major_version_fk_to_major_version.py
@@ -0,0 +1,31 @@
+# Generated by Django 3.2.19 on 2023-08-31 22:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0005_agreementversion_remove_field_major_version'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='agreementversion',
+            options={'ordering': ['major_version', 'minor_version']},
+        ),
+        migrations.RenameField(
+            model_name='agreementversion',
+            old_name='major_version_fk',
+            new_name='major_version',
+        ),
+        migrations.RenameField(
+            model_name='historicalagreementversion',
+            old_name='major_version_fk',
+            new_name='major_version',
+        ),
+        migrations.AddConstraint(
+            model_name='agreementversion',
+            constraint=models.UniqueConstraint(fields=('major_version', 'minor_version'), name='unique_agreement_version_2'),
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 0d2396c8..882ad10a 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -36,11 +36,7 @@ def __str__(self):
 class AgreementVersion(TimeStampedModel, models.Model):
     """Model to track approved CDSA versions."""
 
-    major_version = models.IntegerField(
-        help_text="Major version of the CDSA. Changes to the major version require resigning.",
-        validators=[MinValueValidator(1)],
-    )
-    major_version_fk = models.ForeignKey(
+    major_version = models.ForeignKey(
         AgreementMajorVersion,
         help_text="Major version of the CDSA. Changes to the major version require resigning.",
         on_delete=models.CASCADE,
@@ -62,7 +58,7 @@ class Meta:
         constraints = [
             models.UniqueConstraint(
                 fields=["major_version", "minor_version"],
-                name="unique_agreement_version",
+                name="unique_agreement_version_2",
             )
         ]
         ordering = ["major_version", "minor_version"]
@@ -89,7 +85,7 @@ def get_major_version_absolute_url(self):
 
     @property
     def full_version(self):
-        return "v{}.{}".format(self.major_version, self.minor_version)
+        return "{}.{}".format(self.major_version, self.minor_version)
 
     @property
     def is_valid(self):

From e8733d7cd40ef1f2222947c5bf777142fadaf239 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:14:29 -0700
Subject: [PATCH 14/53] Do not allow major_version to be blank or null

---
 ...07_alter_agreementversion_major_version.py | 20 +++++++++++++++++++
 primed/cdsa/models.py                         |  2 --
 2 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 primed/cdsa/migrations/0007_alter_agreementversion_major_version.py

diff --git a/primed/cdsa/migrations/0007_alter_agreementversion_major_version.py b/primed/cdsa/migrations/0007_alter_agreementversion_major_version.py
new file mode 100644
index 00000000..ced250a9
--- /dev/null
+++ b/primed/cdsa/migrations/0007_alter_agreementversion_major_version.py
@@ -0,0 +1,20 @@
+# Generated by Django 3.2.19 on 2023-08-31 23:14
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0006_agreementversion_rename_major_version_fk_to_major_version'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='agreementversion',
+            name='major_version',
+            field=models.ForeignKey(default=None, help_text='Major version of the CDSA. Changes to the major version require resigning.', on_delete=django.db.models.deletion.CASCADE, to='cdsa.agreementmajorversion'),
+            preserve_default=False,
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 882ad10a..52b1332c 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -40,8 +40,6 @@ class AgreementVersion(TimeStampedModel, models.Model):
         AgreementMajorVersion,
         help_text="Major version of the CDSA. Changes to the major version require resigning.",
         on_delete=models.CASCADE,
-        blank=True,
-        null=True,
     )
     minor_version = models.IntegerField(
         help_text="Minor version of the CDSA. Changes to the minor version do not require resigning.",

From 8c5b4ce9eea4d724c619061c5a79de7c7adf9453 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:20:25 -0700
Subject: [PATCH 15/53] Modify the migration test to cover the set of related
 migrations

Instead of only migrating from before the data migration to immediately
after, migrate from the first migration before any of the changes
(initial) to the last migration in the set (0007) in tests. This is
a better test of what is actually happening (and what we actually
want to happen).
---
 primed/cdsa/tests/test_migrations.py | 33 +++++++++++++++++-----------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/primed/cdsa/tests/test_migrations.py b/primed/cdsa/tests/test_migrations.py
index 708e687f..9eb16740 100644
--- a/primed/cdsa/tests/test_migrations.py
+++ b/primed/cdsa/tests/test_migrations.py
@@ -7,11 +7,11 @@
 
 from . import factories
 
-class PopulateAgreementMajorVersionTest(MigratorTestCase):
-    """Tests for the populate_agreement_major_version migration."""
+class AgreementMajorVersionMigrationsTest(MigratorTestCase):
+    """Tests for the migrations associated with creating the new AgreementMajorVersion model."""
 
-    migrate_from = ("cdsa", "0003_agreementversion_add_major_version_fk")
-    migrate_to = ("cdsa", "0004_populate_agreementmajorversion")
+    migrate_from = ("cdsa", "0001_initial")
+    migrate_to = ("cdsa", "0007_alter_agreementversion_major_version")
 
     def prepare(self):
         """Prepare some data before the migration."""
@@ -60,36 +60,43 @@ def test_agreementmajorversion_model_correctly_populated(self):
         major_version = AgreementMajorVersion.objects.get(version=5)
         major_version.full_clean()
 
-    def test_agreement_version_major_version_fk_correctly_populated(self):
-        """AgreementVersion.major_version_fk is correctly populated."""
+    def test_agreement_version_major_version_correctly_populated(self):
+        """AgreementVersion.major_version is correctly populated."""
         AgreementMajorVersion = self.new_state.apps.get_model("cdsa", "AgreementMajorVersion")
         AgreementVersion = self.new_state.apps.get_model("cdsa", "AgreementVersion")
         # Major version 1.
         major_version = AgreementMajorVersion.objects.get(version=1)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_0.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 0)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_1.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 1)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_1_2.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 2)
         # Major version 2.
         major_version = AgreementMajorVersion.objects.get(version=2)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_2_1.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 1)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_2_3.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 3)
         # Major version 3.
         major_version = AgreementMajorVersion.objects.get(version=3)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_3_0.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 0)
         # Major version 5.
         major_version = AgreementMajorVersion.objects.get(version=5)
         agreement_version = AgreementVersion.objects.get(pk=self.agreement_version_5_6.pk)
-        self.assertEqual(agreement_version.major_version_fk, major_version)
+        agreement_version.full_clean()
+        self.assertEqual(agreement_version.major_version, major_version)
         self.assertEqual(agreement_version.minor_version, 6)

From d2e8da16d07d7fa5f8c5c048f6967f433173e7e3 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:22:55 -0700
Subject: [PATCH 16/53] Add the AgreementMajorVersion model to the admin

---
 primed/cdsa/admin.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/primed/cdsa/admin.py b/primed/cdsa/admin.py
index 6f5d373c..1c30188c 100644
--- a/primed/cdsa/admin.py
+++ b/primed/cdsa/admin.py
@@ -4,6 +4,15 @@
 from . import models
 
 
+@admin.register(models.AgreementMajorVersion)
+class AgreementMajorVersion(SimpleHistoryAdmin):
+    """Admin class for the `AgreementMajorVersion` model."""
+
+    list_display = ("version",)
+    list_filter = ("version",)
+    sortable_by = ("version",)
+
+
 @admin.register(models.AgreementVersion)
 class AgreementVersion(SimpleHistoryAdmin):
     """Admin class for the `AgreementVersion` model."""

From 6b0c201d8d42cb08c8bf679627d1d75c89f283d9 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:26:34 -0700
Subject: [PATCH 17/53] Fix models.py for major_version changes

---
 primed/cdsa/models.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 52b1332c..60a5d921 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -68,22 +68,23 @@ def get_absolute_url(self):
         return reverse(
             "cdsa:agreement_versions:detail",
             kwargs={
-                "major_version": self.major_version,
+                "major_version": self.major_version.version,
                 "minor_version": self.minor_version,
             },
         )
 
     def get_major_version_absolute_url(self):
+        # TODO: remove and change to a detail view on AgreementMajorVersion.
         return reverse(
             "cdsa:agreement_versions:major_version_detail",
             kwargs={
-                "major_version": self.major_version,
+                "major_version": self.major_version.version,
             },
         )
 
     @property
     def full_version(self):
-        return "{}.{}".format(self.major_version, self.minor_version)
+        return "{}.{}".format(str(self.major_version), self.minor_version)
 
     @property
     def is_valid(self):

From 111ba2c4b8b21ae1cf6441134b7b057be7e7465d Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 16:57:53 -0700
Subject: [PATCH 18/53] Update factories and models for major_version change

---
 primed/cdsa/tests/factories.py   |  3 +-
 primed/cdsa/tests/test_models.py | 55 +++++++++++---------------------
 2 files changed, 21 insertions(+), 37 deletions(-)

diff --git a/primed/cdsa/tests/factories.py b/primed/cdsa/tests/factories.py
index 1c8a81ea..bf0459b8 100644
--- a/primed/cdsa/tests/factories.py
+++ b/primed/cdsa/tests/factories.py
@@ -19,6 +19,7 @@ class AgreementMajorVersionFactory(DjangoModelFactory):
 
     class Meta:
         model = models.AgreementMajorVersion
+        django_get_or_create = ("version",)
 
     version = Faker("random_int", min=1)
 
@@ -29,7 +30,7 @@ class AgreementVersionFactory(DjangoModelFactory):
     class Meta:
         model = models.AgreementVersion
 
-    major_version = Faker("random_int", min=1)
+    major_version = SubFactory(AgreementMajorVersionFactory)
     minor_version = Faker("random_int")
     date_approved = Faker("date")
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 1f42d65b..1c52e12a 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -78,54 +78,40 @@ class AgreementVersionTest(TestCase):
     """Tests for the AgreementVersion model."""
 
     def test_model_saving(self):
+        major_version = factories.AgreementMajorVersionFactory.create()
         instance = models.AgreementVersion(
-            major_version=1, minor_version=0, date_approved=datetime.today()
+            major_version=major_version, minor_version=0, date_approved=datetime.today()
         )
         instance.save()
         self.assertIsInstance(instance, models.AgreementVersion)
 
     def test_unique(self):
-        factories.AgreementVersionFactory.create(major_version=1, minor_version=0)
+        major_version = factories.AgreementMajorVersionFactory.create()
+        factories.AgreementVersionFactory.create(
+            major_version=major_version, minor_version=0
+        )
         instance = factories.AgreementVersionFactory.build(
-            major_version=1, minor_version=0
+            major_version=major_version, minor_version=0
         )
         with self.assertRaisesMessage(ValidationError, "already exists"):
             instance.full_clean()
         with self.assertRaises(IntegrityError):
             instance.save()
 
-    def test_major_version_zero(self):
-        """ValidationError raised when major_version is zero."""
-        instance = factories.AgreementVersionFactory.build(major_version=0)
-        with self.assertRaises(ValidationError) as e:
-            instance.full_clean()
-        self.assertEqual(len(e.exception.message_dict), 1)
-        self.assertIn("major_version", e.exception.message_dict)
-        self.assertEqual(len(e.exception.message_dict["major_version"]), 1)
-        self.assertIn(
-            "greater than or equal to", e.exception.message_dict["major_version"][0]
-        )
-
-    def test_major_version_negative(self):
-        """ValidationError raised when major_version is negative."""
-        instance = factories.AgreementVersionFactory.build(major_version=-1)
-        with self.assertRaises(ValidationError) as e:
-            instance.full_clean()
-        self.assertEqual(len(e.exception.message_dict), 1)
-        self.assertIn("major_version", e.exception.message_dict)
-        self.assertEqual(len(e.exception.message_dict["major_version"]), 1)
-        self.assertIn(
-            "greater than or equal to", e.exception.message_dict["major_version"][0]
-        )
-
     def test_minor_version_zero(self):
         """full_clean raises no exception when minor_version is zero."""
-        instance = factories.AgreementVersionFactory.build(minor_version=0)
+        major_version = factories.AgreementMajorVersionFactory.create()
+        instance = factories.AgreementVersionFactory.build(
+            major_version=major_version, minor_version=0
+        )
         instance.full_clean()
 
     def test_minor_version_negative(self):
         """ValidationError raised when minor_version is negative."""
-        instance = factories.AgreementVersionFactory.build(minor_version=-1)
+        major_version = factories.AgreementMajorVersionFactory.create()
+        instance = factories.AgreementVersionFactory.build(
+            major_version=major_version, minor_version=-1
+        )
         with self.assertRaises(ValidationError) as e:
             instance.full_clean()
         self.assertEqual(len(e.exception.message_dict), 1)
@@ -139,25 +125,25 @@ def test_full_version(self):
         """full_version property works as expected."""
         self.assertEqual(
             factories.AgreementVersionFactory(
-                major_version=1, minor_version=0
+                major_version__version=1, minor_version=0
             ).full_version,
             "v1.0",
         )
         self.assertEqual(
             factories.AgreementVersionFactory(
-                major_version=1, minor_version=5
+                major_version__version=1, minor_version=5
             ).full_version,
             "v1.5",
         )
         self.assertEqual(
             factories.AgreementVersionFactory(
-                major_version=1, minor_version=10
+                major_version__version=1, minor_version=10
             ).full_version,
             "v1.10",
         )
         self.assertEqual(
             factories.AgreementVersionFactory(
-                major_version=2, minor_version=3
+                major_version__version=2, minor_version=3
             ).full_version,
             "v2.3",
         )
@@ -263,7 +249,6 @@ def test_cc_id_zero(self):
         user = UserFactory.create()
         group = ManagedGroupFactory.create()
         agreement_version = factories.AgreementVersionFactory.create()
-        instance = factories.AgreementVersionFactory.build(major_version=0)
         instance = factories.SignedAgreementFactory.build(
             cc_id=0,
             representative=user,
@@ -282,7 +267,6 @@ def test_cc_id_negative(self):
         user = UserFactory.create()
         group = ManagedGroupFactory.create()
         agreement_version = factories.AgreementVersionFactory.create()
-        instance = factories.AgreementVersionFactory.build(major_version=0)
         instance = factories.SignedAgreementFactory.build(
             cc_id=-1,
             representative=user,
@@ -344,7 +328,6 @@ def test_clean_non_data_affiliate_is_primary_false(self):
         user = UserFactory.create()
         group = ManagedGroupFactory.create()
         agreement_version = factories.AgreementVersionFactory.create()
-        instance = factories.AgreementVersionFactory.build(major_version=0)
         instance = factories.SignedAgreementFactory.build(
             representative=user,
             anvil_access_group=group,

From 830b125e0124cda58105d163c46c38a6913b9060 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 17:06:50 -0700
Subject: [PATCH 19/53] Update AgreementVersionDetail for major_version changes

---
 primed/cdsa/tests/test_views.py               | 38 +++++++------------
 primed/cdsa/views.py                          |  5 ++-
 .../cdsa/agreementversion_detail.html         |  2 +-
 3 files changed, 18 insertions(+), 27 deletions(-)

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index d7063a98..ad5fcecf 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -283,7 +283,7 @@ def test_status_code_with_user_permission(self):
         """Returns successful response code."""
         self.client.force_login(self.user)
         response = self.client.get(
-            self.get_url(self.obj.major_version, self.obj.minor_version)
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
         )
         self.assertEqual(response.status_code, 200)
 
@@ -302,59 +302,47 @@ def test_view_status_code_with_existing_object(self):
         # Only clients load the template.
         self.client.force_login(self.user)
         response = self.client.get(
-            self.get_url(self.obj.major_version, self.obj.minor_version)
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
         )
         self.assertEqual(response.status_code, 200)
 
     def test_view_status_code_with_invalid_version(self):
         """Raises a 404 error with an invalid major and minor version."""
         request = self.factory.get(
-            self.get_url(self.obj.major_version + 1, self.obj.minor_version + 1)
+            self.get_url(self.obj.major_version.version + 1, self.obj.minor_version + 1)
         )
         request.user = self.user
         with self.assertRaises(Http404):
             self.get_view()(
                 request,
-                major_version=self.obj.major_version + 1,
+                major_version=self.obj.major_version.version + 1,
                 minor_version=self.obj.minor_version + 1,
             )
 
     def test_view_status_code_with_other_major_version(self):
         """Raises a 404 error with an invalid object major version."""
-        other_agreement = factories.AgreementVersionFactory.create(
-            major_version=self.obj.major_version + 1,
-            minor_version=self.obj.minor_version,
-        )
         request = self.factory.get(
-            self.get_url(
-                other_agreement.major_version + 1, other_agreement.minor_version
-            )
+            self.get_url(self.obj.major_version.version + 1, self.obj.minor_version)
         )
         request.user = self.user
         with self.assertRaises(Http404):
             self.get_view()(
                 request,
-                major_version=other_agreement.major_version + 1,
-                minor_version=other_agreement.minor_version,
+                major_version__version=self.obj.major_version.version + 1,
+                minor_version=self.obj.minor_version,
             )
 
     def test_view_status_code_with_other_minor_version(self):
         """Raises a 404 error with an invalid object minor version."""
-        other_agreement = factories.AgreementVersionFactory.create(
-            major_version=self.obj.major_version,
-            minor_version=self.obj.minor_version + 1,
-        )
         request = self.factory.get(
-            self.get_url(
-                other_agreement.major_version, other_agreement.minor_version + 1
-            )
+            self.get_url(self.obj.major_version.version, self.obj.minor_version + 1)
         )
         request.user = self.user
         with self.assertRaises(Http404):
             self.get_view()(
                 request,
-                major_version=other_agreement.major_version,
-                minor_version=other_agreement.minor_version + 1,
+                major_version=self.obj.major_version.version,
+                minor_version=self.obj.minor_version + 1,
             )
 
     # def test_response_includes_link_to_major_agreement(self):
@@ -369,7 +357,7 @@ def test_response_includes_signed_agreement_table(self):
         """Response includes a table of SignedAgreements."""
         self.client.force_login(self.user)
         response = self.client.get(
-            self.get_url(self.obj.major_version, self.obj.minor_version)
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn("signed_agreement_table", response.context_data)
@@ -390,7 +378,7 @@ def test_response_signed_agreement_table_three_agreements(self):
         )
         self.client.force_login(self.user)
         response = self.client.get(
-            self.get_url(self.obj.major_version, self.obj.minor_version)
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.context_data["signed_agreement_table"].rows), 3)
@@ -414,7 +402,7 @@ def test_response_signed_agreement_table_other_version(self):
         nda_agreement = factories.NonDataAffiliateAgreementFactory.create()
         self.client.force_login(self.user)
         response = self.client.get(
-            self.get_url(self.obj.major_version, self.obj.minor_version)
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.context_data["signed_agreement_table"].rows), 0)
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 4cf0839a..e47322a0 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -29,6 +29,7 @@ class AgreementMajorVersionDetail(
 ):
     """Display a "detail" page for an agreement major version (e.g., 1.x)."""
 
+    # TODO: update for new model.
     template_name = "cdsa/agreementmajorversion_detail.html"
     tables = (tables.AgreementVersionTable, tables.SignedAgreementTable)
 
@@ -80,7 +81,9 @@ def get_object(self, queryset=None):
         try:
             major_version = self.kwargs["major_version"]
             minor_version = self.kwargs["minor_version"]
-            obj = queryset.get(major_version=major_version, minor_version=minor_version)
+            obj = queryset.get(
+                major_version__version=major_version, minor_version=minor_version
+            )
         except (KeyError, self.model.DoesNotExist):
             raise Http404(
                 _("No %(verbose_name)s found matching the query")
diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
index b4ea8007..59f01599 100644
--- a/primed/templates/cdsa/agreementversion_detail.html
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -7,7 +7,7 @@
 <dl class="row">
   <dt class="col-sm-2">Full version</dt> <dd class="col-sm-9">{{ object.full_version }}</dd>
   <dt class="col-sm-2">Major version</dt> <dd class="col-sm-9">
-    <a href="{{ object.get_major_version_absolute_url }}">v{{ object.major_version }}</a>
+    <a href="{{ object.get_major_version_absolute_url }}">{{ object.major_version }}</a>
   </dd>
 
   <dt class="col-sm-2">Date approved</dt> <dd class="col-sm-9">{{ object.date_approved }}</dd>

From 4abbe28ad19e8384e9682b4f389ec173804ce252 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 17:23:42 -0700
Subject: [PATCH 20/53] Update AgreementMajorVersionDetail to be a DetailView

Instead of having AgreementMajorVersion be a template view that
operates on a non-existent model class, use a detail view that
pulls and instance of the AgreementMajorVersion model. Add a
get_absolute_url method to AgreementMajorVersion, and remove the
get_major_version_absolute_url method from AgreementVersion since
it is no longer necessary. Update tables and templates as necessary
for the removal of this method.
---
 primed/cdsa/models.py                         | 18 +++-----
 primed/cdsa/tables.py                         |  4 +-
 primed/cdsa/tests/test_models.py              | 13 ++----
 primed/cdsa/tests/test_views.py               | 45 +++++++------------
 primed/cdsa/views.py                          | 32 ++++++-------
 .../cdsa/agreementmajorversion_detail.html    |  4 +-
 .../cdsa/agreementversion_detail.html         |  2 +-
 7 files changed, 45 insertions(+), 73 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 60a5d921..ed4dc201 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -29,8 +29,13 @@ class AgreementMajorVersion(TimeStampedModel, models.Model):
     def __str__(self):
         return "v{}".format(self.version)
 
-    # def get_absolute_url(self):
-    #     pass
+    def get_absolute_url(self):
+        return reverse(
+            "cdsa:agreement_versions:major_version_detail",
+            kwargs={
+                "major_version": self.version,
+            },
+        )
 
 
 class AgreementVersion(TimeStampedModel, models.Model):
@@ -73,15 +78,6 @@ def get_absolute_url(self):
             },
         )
 
-    def get_major_version_absolute_url(self):
-        # TODO: remove and change to a detail view on AgreementMajorVersion.
-        return reverse(
-            "cdsa:agreement_versions:major_version_detail",
-            kwargs={
-                "major_version": self.major_version.version,
-            },
-        )
-
     @property
     def full_version(self):
         return "{}.{}".format(str(self.major_version), self.minor_version)
diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 87631427..b987b2ef 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -17,9 +17,7 @@
 
 class AgreementVersionTable(tables.Table):
 
-    major_version = tables.Column(
-        linkify=lambda record: record.get_major_version_absolute_url()
-    )
+    major_version = tables.Column(linkify=True)
     full_version = tables.Column(
         linkify=True, order_by=("major_version", "minor_version")
     )
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 1c52e12a..63be9d67 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -68,10 +68,10 @@ def test_str(self):
         instance = factories.AgreementMajorVersionFactory.build()
         self.assertIsInstance(str(instance), str)
 
-    # def test_get_absolute_url(self):
-    #     """get_absolute_url method works correctly."""
-    #     instance = factories.AgreementMajorVersionFactory.create()
-    #     self.assertIsInstance(instance.get_absolute_url(), str)
+    def test_get_absolute_url(self):
+        """get_absolute_url method works correctly."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.assertIsInstance(instance.get_absolute_url(), str)
 
 
 class AgreementVersionTest(TestCase):
@@ -158,11 +158,6 @@ def test_get_absolute_url(self):
         instance = factories.AgreementVersionFactory.create()
         self.assertIsInstance(instance.get_absolute_url(), str)
 
-    def test_get_major_version_absolute_url(self):
-        """test_get_major_version_absolute_url method works correctly."""
-        instance = factories.AgreementVersionFactory.create()
-        self.assertIsInstance(instance.get_major_version_absolute_url(), str)
-
 
 class SignedAgreementTest(TestCase):
     """Tests for the SignedAgreement model."""
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index ad5fcecf..fa3a48b4 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -126,7 +126,7 @@ def setUp(self):
             )
         )
         # Create an object test this with.
-        self.obj = factories.AgreementVersionFactory.create()
+        self.obj = factories.AgreementMajorVersionFactory.create()
 
     def get_url(self, *args):
         """Get the url for the view being tested."""
@@ -148,7 +148,7 @@ def test_view_redirect_not_logged_in(self):
     def test_status_code_with_user_permission(self):
         """Returns successful response code."""
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
+        response = self.client.get(self.get_url(self.obj.version))
         self.assertEqual(response.status_code, 200)
 
     def test_access_without_user_permission(self):
@@ -165,30 +165,22 @@ def test_view_status_code_with_existing_object(self):
         """Returns a successful status code for an existing object pk."""
         # Only clients load the template.
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
+        response = self.client.get(self.get_url(self.obj.version))
         self.assertEqual(response.status_code, 200)
 
     def test_view_status_code_with_invalid_version(self):
         """Raises a 404 error with an invalid major and minor version."""
-        request = self.factory.get(self.get_url(self.obj.major_version + 1))
+        request = self.factory.get(self.get_url(self.obj.version + 1))
         request.user = self.user
         with self.assertRaises(Http404):
             self.get_view()(
                 request,
-                major_version=self.obj.major_version + 1,
+                major_version=self.obj.version + 1,
             )
 
-    def test_context_major_version(self):
-        """Context includes major_version."""
-        self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
-        self.assertEqual(response.status_code, 200)
-        self.assertIn("major_version", response.context_data)
-        self.assertEqual(response.context_data["major_version"], self.obj.major_version)
-
     def test_context_table_classes(self):
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
+        response = self.client.get(self.get_url(self.obj.version))
         self.assertEqual(response.status_code, 200)
         self.assertIn("tables", response.context_data)
         self.assertEqual(len(response.context_data["tables"]), 2)
@@ -201,37 +193,34 @@ def test_context_table_classes(self):
 
     def test_response_includes_agreement_version_table(self):
         """agreement_version_table includes agreement_versions with this major version."""
-        factories.AgreementVersionFactory.create(major_version=self.obj.major_version)
+        factories.AgreementVersionFactory.create(major_version=self.obj)
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
-        # 2 - one for the object we created in the setup method, one for the new object in this test.
-        self.assertEqual(len(response.context_data["tables"][0].rows), 2)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(len(response.context_data["tables"][0].rows), 1)
 
     def test_response_includes_agreement_version_table_other_major_version(self):
         """agreement_version_table includes only agreement_versions with this major version."""
         other_agreement = factories.AgreementVersionFactory.create(
-            major_version=self.obj.major_version + 1
+            major_version__version=self.obj.version + 1
         )
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
-        # 2 - one for the object we created in the setup method, one for the new object in this test.
-        self.assertEqual(len(response.context_data["tables"][0].rows), 1)
-        self.assertIn(self.obj, response.context_data["tables"][0].data)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(len(response.context_data["tables"][0].rows), 0)
         self.assertNotIn(other_agreement, response.context_data["tables"][0].data)
 
     def test_response_signed_agreement_table_three_agreements(self):
         """signed_agreement_table includes all types of agreements."""
         factories.MemberAgreementFactory.create(
-            signed_agreement__version__major_version=self.obj.major_version
+            signed_agreement__version__major_version__version=self.obj.version
         )
         factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__version__major_version=self.obj.major_version
+            signed_agreement__version__major_version__version=self.obj.version
         )
         factories.NonDataAffiliateAgreementFactory.create(
-            signed_agreement__version__major_version=self.obj.major_version
+            signed_agreement__version__major_version__version=self.obj.version
         )
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
+        response = self.client.get(self.get_url(self.obj.version))
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.context_data["tables"][1].rows), 3)
 
@@ -241,7 +230,7 @@ def test_response_signed_agreement_table_other_major_version(self):
         factories.DataAffiliateAgreementFactory.create()
         factories.NonDataAffiliateAgreementFactory.create()
         self.client.force_login(self.user)
-        response = self.client.get(self.get_url(self.obj.major_version))
+        response = self.client.get(self.get_url(self.obj.version))
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.context_data["tables"][1].rows), 0)
 
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index e47322a0..88bbd6fe 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -25,41 +25,35 @@
 
 
 class AgreementMajorVersionDetail(
-    AnVILConsortiumManagerViewRequired, MultiTableMixin, TemplateView
+    AnVILConsortiumManagerViewRequired, MultiTableMixin, DetailView
 ):
     """Display a "detail" page for an agreement major version (e.g., 1.x)."""
 
-    # TODO: update for new model.
+    model = models.AgreementMajorVersion
     template_name = "cdsa/agreementmajorversion_detail.html"
     tables = (tables.AgreementVersionTable, tables.SignedAgreementTable)
 
-    def get_major_version(self):
-        major_version = self.kwargs.get("major_version")
-        qs = models.AgreementVersion.objects.filter(major_version=major_version)
-        if not qs.count():
+    def get_object(self, queryset=None):
+        queryset = self.model.objects.all()
+        try:
+            major_version = self.kwargs["major_version"]
+            obj = queryset.get(version=major_version)
+        except (KeyError, self.model.DoesNotExist):
             raise Http404(
-                _("No AgreementVersions with major_version found matching the query")
+                _("No %(verbose_name)s found matching the query")
+                % {"verbose_name": queryset.model._meta.verbose_name}
             )
-        return major_version
-
-    def get(self, request, *args, **kwargs):
-        self.major_version = self.get_major_version()
-        return super().get(request, *args, **kwargs)
+        return obj
 
     def get_tables_data(self):
         agreement_version_qs = models.AgreementVersion.objects.filter(
-            major_version=self.major_version
+            major_version=self.object
         )
         signed_agreement_qs = models.SignedAgreement.objects.filter(
-            version__major_version=self.major_version
+            version__major_version=self.object
         )
         return [agreement_version_qs, signed_agreement_qs]
 
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data()
-        context["major_version"] = self.major_version
-        return context
-
 
 class AgreementVersionDetail(
     AnVILConsortiumManagerViewRequired, SingleTableMixin, DetailView
diff --git a/primed/templates/cdsa/agreementmajorversion_detail.html b/primed/templates/cdsa/agreementmajorversion_detail.html
index e306464e..2a8edd2a 100644
--- a/primed/templates/cdsa/agreementmajorversion_detail.html
+++ b/primed/templates/cdsa/agreementmajorversion_detail.html
@@ -1,11 +1,11 @@
 {% extends "anvil_consortium_manager/__object_detail.html" %}
 {% load django_tables2 %}
 
-{% block title %}Agreement version v{{ major_version }}{% endblock %}
+{% block title %}Agreement version v{{ object.version }}{% endblock %}
 
 {% block panel %}
 <dl class="row">
-  <dt class="col-sm-2">Version</dt> <dd class="col-sm-9"> v{{ major_version }}</dd>
+  <dt class="col-sm-2">Version</dt> <dd class="col-sm-9"> v{{ object.version }}</dd>
 </dl>
 {% endblock panel %}
 
diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
index 59f01599..fac00071 100644
--- a/primed/templates/cdsa/agreementversion_detail.html
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -7,7 +7,7 @@
 <dl class="row">
   <dt class="col-sm-2">Full version</dt> <dd class="col-sm-9">{{ object.full_version }}</dd>
   <dt class="col-sm-2">Major version</dt> <dd class="col-sm-9">
-    <a href="{{ object.get_major_version_absolute_url }}">{{ object.major_version }}</a>
+    <a href="{{ object.major_version.get_absolute_url }}">{{ object.major_version }}</a>
   </dd>
 
   <dt class="col-sm-2">Date approved</dt> <dd class="col-sm-9">{{ object.date_approved }}</dd>

From 2196357f46ec6f8d4f5c1de16b065274266491d3 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 31 Aug 2023 17:31:23 -0700
Subject: [PATCH 21/53] Remove now-extraneous v from AgreementVersionTable

---
 primed/cdsa/tables.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index b987b2ef..a0d16bcb 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -30,9 +30,6 @@ class Meta:
             "date_approved",
         )
 
-    def render_major_version(self, record):
-        return "v{}".format(record.major_version)
-
 
 class SignedAgreementTable(tables.Table):
 

From 13e0e6216317a81d12db3b4d5c7f8b908e26adc6 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 1 Sep 2023 09:23:04 -0700
Subject: [PATCH 22/53] Add dev CDSA group setting back to local config

---
 config/settings/local.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/config/settings/local.py b/config/settings/local.py
index 252382b3..b6b17daa 100644
--- a/config/settings/local.py
+++ b/config/settings/local.py
@@ -76,3 +76,4 @@
 ANVIL_DATA_ACCESS_GROUP_PREFIX = env(
     "ANVIL_DATA_ACCESS_GROUP_PREFIX", default="DEV_PRIMED"
 )
+ANVIL_CDSA_GROUP_NAME = env("ANVIL_CDSA_GROUP_NAME", default="DEV_PRIMED_CDSA")

From b5c1c8d711536099e2a726598ac7112d0caec2a6 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 1 Sep 2023 09:29:23 -0700
Subject: [PATCH 23/53] Add CSDA version to audit tables

Also modify the table dictionaries/table columns to use accessors
instead of passing each value in the table dictionary (eg, signed
agreement types can be derived from the signed_agreement using an
accessor instead of passed separately).
---
 primed/cdsa/audit/signed_agreement_audit.py | 7 +++----
 primed/cdsa/audit/workspace_audit.py        | 3 +++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/primed/cdsa/audit/signed_agreement_audit.py b/primed/cdsa/audit/signed_agreement_audit.py
index 19002e6a..a1ad81f2 100644
--- a/primed/cdsa/audit/signed_agreement_audit.py
+++ b/primed/cdsa/audit/signed_agreement_audit.py
@@ -39,8 +39,6 @@ def get_table_dictionary(self):
         """Return a dictionary that can be used to populate an instance of `SignedAgreementAccessAuditTable`."""
         row = {
             "signed_agreement": self.signed_agreement,
-            "agreement_group": self.signed_agreement.agreement_group,
-            "agreement_type": self.signed_agreement.combined_type,
             "note": self.note,
             "action": self.get_action(),
             "action_url": self.get_action_url(),
@@ -107,8 +105,9 @@ class SignedAgreementAccessAuditTable(tables.Table):
     """A table to show results from a SignedAgreementAccessAudit instance."""
 
     signed_agreement = tables.Column(linkify=True)
-    agreement_group = tables.Column()
-    agreement_type = tables.Column()
+    agreement_group = tables.Column(accessor="signed_agreement__agreement_group")
+    agreement_type = tables.Column(accessor="signed_agreement__combined_type")
+    agreement_version = tables.Column(accessor="signed_agreement__version")
     note = tables.Column()
     action = tables.Column()
 
diff --git a/primed/cdsa/audit/workspace_audit.py b/primed/cdsa/audit/workspace_audit.py
index 2d7d9267..2d41d60b 100644
--- a/primed/cdsa/audit/workspace_audit.py
+++ b/primed/cdsa/audit/workspace_audit.py
@@ -107,6 +107,9 @@ class WorkspaceAccessAuditTable(tables.Table):
 
     workspace = tables.Column(linkify=True)
     data_affiliate_agreement = tables.Column(linkify=True)
+    agreement_version = tables.Column(
+        accessor="data_affiliate_agreement__signed_agreement__version"
+    )
     note = tables.Column()
     action = tables.Column()
 

From 4d8174856836b8b4bd061fade052456ec5fb6d65 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 1 Sep 2023 11:03:59 -0700
Subject: [PATCH 24/53] Modify test data script for migration changes

---
 add_cdsa_example_data.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/add_cdsa_example_data.py b/add_cdsa_example_data.py
index 16152baf..c4f9d599 100644
--- a/add_cdsa_example_data.py
+++ b/add_cdsa_example_data.py
@@ -17,9 +17,16 @@
 from primed.users.models import User
 from primed.users.tests.factories import UserFactory
 
+# Create major versions
+major_version = factories.AgreementMajorVersionFactory.create(version=1)
+
 # Create some agreement versions
-v10 = factories.AgreementVersionFactory.create(major_version=1, minor_version=0)
-v11 = factories.AgreementVersionFactory.create(major_version=1, minor_version=1)
+v10 = factories.AgreementVersionFactory.create(
+    major_version=major_version, minor_version=0
+)
+v11 = factories.AgreementVersionFactory.create(
+    major_version=major_version, minor_version=1
+)
 
 # Create a couple signed CDSAs.
 dup = DataUsePermissionFactory.create(abbreviation="GRU")

From 1741f728e955adc84219abca7e9cc5feb7bb10bd Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 13 Sep 2023 16:17:28 -0700
Subject: [PATCH 25/53] Add a status field to AgreementMajorVersion

This field indicates if the version is a valid CDSA or a deprecated
CDSA. Also display this information in the AgreementVersionTable
as a column as well on various detail pages as a pill.
---
 primed/cdsa/admin.py                          |  17 ++-
 .../0008_agreementmajorversion_add_status.py  |  35 ++++++
 primed/cdsa/models.py                         |  17 ++-
 primed/cdsa/tables.py                         |   1 +
 primed/cdsa/tests/test_models.py              |  10 ++
 primed/cdsa/tests/test_views.py               | 110 ++++++++++++++++++
 primed/cdsa/views.py                          |  38 ++++++
 .../cdsa/agreementmajorversion_detail.html    |  12 ++
 .../cdsa/agreementversion_detail.html         |   9 ++
 .../cdsa/dataaffiliateagreement_detail.html   |   9 ++
 .../cdsa/memberagreement_detail.html          |   9 ++
 .../nondataaffiliateagreement_detail.html     |   9 ++
 12 files changed, 269 insertions(+), 7 deletions(-)
 create mode 100644 primed/cdsa/migrations/0008_agreementmajorversion_add_status.py

diff --git a/primed/cdsa/admin.py b/primed/cdsa/admin.py
index 1c30188c..a4beda1f 100644
--- a/primed/cdsa/admin.py
+++ b/primed/cdsa/admin.py
@@ -8,8 +8,14 @@
 class AgreementMajorVersion(SimpleHistoryAdmin):
     """Admin class for the `AgreementMajorVersion` model."""
 
-    list_display = ("version",)
-    list_filter = ("version",)
+    list_display = (
+        "version",
+        "status",
+    )
+    list_filter = (
+        "version",
+        "status",
+    )
     sortable_by = ("version",)
 
 
@@ -19,11 +25,12 @@ class AgreementVersion(SimpleHistoryAdmin):
 
     list_display = (
         "full_version",
-        "major_version",
-        "minor_version",
         "date_approved",
     )
-    list_filter = ("major_version",)
+    list_filter = (
+        "major_version",
+        "major_version__status",
+    )
     sortable_by = (
         "major_version",
         "minor_version",
diff --git a/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py b/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py
new file mode 100644
index 00000000..639b3b60
--- /dev/null
+++ b/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py
@@ -0,0 +1,35 @@
+# Generated by Django 3.2.19 on 2023-09-13 22:48
+
+from django.db import migrations
+import django.utils.timezone
+import model_utils.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0007_alter_agreementversion_major_version'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='agreementmajorversion',
+            name='status',
+            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='valid', max_length=100, no_check_for_status=True, verbose_name='status'),
+        ),
+        migrations.AddField(
+            model_name='agreementmajorversion',
+            name='status_changed',
+            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
+        ),
+        migrations.AddField(
+            model_name='historicalagreementmajorversion',
+            name='status',
+            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='valid', max_length=100, no_check_for_status=True, verbose_name='status'),
+        ),
+        migrations.AddField(
+            model_name='historicalagreementmajorversion',
+            name='status_changed',
+            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index ed4dc201..9331014a 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -9,13 +9,26 @@
 from django.db import models
 from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
+from model_utils.models import StatusModel
 from simple_history.models import HistoricalRecords
 
 from primed.duo.models import DataUseOntologyModel
 from primed.primed_anvil.models import AvailableData, RequesterModel, Study, StudySite
 
 
-class AgreementMajorVersion(TimeStampedModel, models.Model):
+class AgreementMajorVersionStatusMixin:
+    # Workaround to use django-simple-history and django-model-utils StatusField together.
+    VALID = "valid"
+    DEPRECATED = "deprecated"
+    STATUS = (
+        (VALID, "Valid"),
+        (DEPRECATED, "Deprecated"),
+    )
+
+
+class AgreementMajorVersion(
+    TimeStampedModel, StatusModel, AgreementMajorVersionStatusMixin, models.Model
+):
     """A model for a major agreement version."""
 
     version = models.IntegerField(
@@ -24,7 +37,7 @@ class AgreementMajorVersion(TimeStampedModel, models.Model):
         unique=True,
     )
 
-    history = HistoricalRecords()
+    history = HistoricalRecords(bases=[AgreementMajorVersionStatusMixin, models.Model])
 
     def __str__(self):
         return "v{}".format(self.version)
diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index a0d16bcb..6873088b 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -27,6 +27,7 @@ class Meta:
         fields = (
             "major_version",
             "full_version",
+            "major_version__status",
             "date_approved",
         )
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 63be9d67..9a8e7407 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -31,6 +31,16 @@ def test_model_saving(self):
         instance.save()
         self.assertIsInstance(instance, models.AgreementMajorVersion)
 
+    def test_status_default(self):
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.assertEqual(instance.status, models.AgreementMajorVersion.VALID)
+
+    def test_status_deprecated(self):
+        instance = factories.AgreementMajorVersionFactory.create(
+            status=models.AgreementMajorVersion.DEPRECATED
+        )
+        self.assertEqual(instance.status, models.AgreementMajorVersion.DEPRECATED)
+
     def test_unique(self):
         factories.AgreementMajorVersionFactory.create(version=1)
         instance = factories.AgreementMajorVersionFactory.build(version=1)
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index fa3a48b4..153fb0f1 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -234,6 +234,26 @@ def test_response_signed_agreement_table_other_major_version(self):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(response.context_data["tables"][1].rows), 0)
 
+    def test_response_show_deprecation_message_valid(self):
+        """response context does not show a deprecation warning when AgreementMajorVersion is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertFalse(response.context_data["show_deprecation_message"])
+        self.assertNotIn(b"Deprecated", response.content)
+
+    def test_response_show_deprecation_message_deprecated(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
+        self.obj.status = self.obj.DEPRECATED
+        self.obj.save()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertTrue(response.context_data["show_deprecation_message"])
+        self.assertIn(b"Deprecated", response.content)
+
 
 class AgreementVersionDetailTest(TestCase):
     """Tests for the AgreementVersionDetail view."""
@@ -408,6 +428,30 @@ def test_response_signed_agreement_table_other_version(self):
             response.context_data["signed_agreement_table"].data,
         )
 
+    def test_response_show_deprecation_message_valid(self):
+        """response context does not show a deprecation warning when AgreementMajorVersion is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertFalse(response.context_data["show_deprecation_message"])
+        self.assertNotIn(b"Deprecated", response.content)
+
+    def test_response_show_deprecation_message_deprecated(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
+        self.obj.major_version.status = self.obj.major_version.DEPRECATED
+        self.obj.major_version.save()
+        self.client.force_login(self.user)
+        response = self.client.get(
+            self.get_url(self.obj.major_version.version, self.obj.minor_version)
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertTrue(response.context_data["show_deprecation_message"])
+        self.assertIn(b"Deprecated", response.content)
+
 
 class SignedAgreementListTest(TestCase):
     """Tests for the SignedAgreementList view."""
@@ -1413,6 +1457,28 @@ def test_response_includes_link_to_anvil_access_group(self):
             response, self.obj.signed_agreement.anvil_access_group.get_absolute_url()
         )
 
+    def test_response_show_deprecation_message_valid(self):
+        """response context does not show a deprecation warning when AgreementMajorVersion is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertFalse(response.context_data["show_deprecation_message"])
+        self.assertNotIn(b"Deprecated CDSA version", response.content)
+
+    def test_response_show_deprecation_message_deprecated(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
+        self.obj.signed_agreement.version.major_version.status = (
+            models.AgreementMajorVersion.DEPRECATED
+        )
+        self.obj.signed_agreement.version.major_version.save()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertTrue(response.context_data["show_deprecation_message"])
+        self.assertIn(b"Deprecated CDSA version", response.content)
+
 
 class MemberAgreementListTest(TestCase):
     """Tests for the MemberAgreementList view."""
@@ -2567,6 +2633,28 @@ def test_response_includes_link_to_anvil_upload_group(self):
         response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
         self.assertContains(response, self.obj.anvil_upload_group.get_absolute_url())
 
+    def test_response_show_deprecation_message_valid(self):
+        """response context does not show a deprecation warning when AgreementMajorVersion is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertFalse(response.context_data["show_deprecation_message"])
+        self.assertNotIn(b"Deprecated CDSA version", response.content)
+
+    def test_response_show_deprecation_message_deprecated(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
+        self.obj.signed_agreement.version.major_version.status = (
+            models.AgreementMajorVersion.DEPRECATED
+        )
+        self.obj.signed_agreement.version.major_version.save()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertTrue(response.context_data["show_deprecation_message"])
+        self.assertIn(b"Deprecated CDSA version", response.content)
+
 
 class DataAffiliateAgreementListTest(TestCase):
     """Tests for the DataAffiliateAgreement view."""
@@ -3548,6 +3636,28 @@ def test_response_includes_link_to_anvil_access_group(self):
             response, self.obj.signed_agreement.anvil_access_group.get_absolute_url()
         )
 
+    def test_response_show_deprecation_message_valid(self):
+        """response context does not show a deprecation warning when AgreementMajorVersion is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertFalse(response.context_data["show_deprecation_message"])
+        self.assertNotIn(b"Deprecated CDSA version", response.content)
+
+    def test_response_show_deprecation_message_deprecated(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
+        self.obj.signed_agreement.version.major_version.status = (
+            models.AgreementMajorVersion.DEPRECATED
+        )
+        self.obj.signed_agreement.version.major_version.save()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_deprecation_message", response.context_data)
+        self.assertTrue(response.context_data["show_deprecation_message"])
+        self.assertIn(b"Deprecated CDSA version", response.content)
+
 
 class NonDataAffiliateAgreementListTest(TestCase):
     """Tests for the NonDataAffiliateAgreement view."""
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 88bbd6fe..651e9591 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -54,6 +54,13 @@ def get_tables_data(self):
         )
         return [agreement_version_qs, signed_agreement_qs]
 
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_deprecation_message"] = (
+            self.object.status == self.object.DEPRECATED
+        )
+        return context
+
 
 class AgreementVersionDetail(
     AnVILConsortiumManagerViewRequired, SingleTableMixin, DetailView
@@ -85,6 +92,13 @@ def get_object(self, queryset=None):
             )
         return obj
 
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_deprecation_message"] = (
+            self.object.major_version.status == self.object.major_version.DEPRECATED
+        )
+        return context
+
 
 class AgreementVersionList(AnVILConsortiumManagerViewRequired, SingleTableView):
     """Display a list of AgreementVersions."""
@@ -284,6 +298,14 @@ def get_object(self, queryset=None):
             )
         return obj
 
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_deprecation_message"] = (
+            self.object.signed_agreement.version.major_version.status
+            == models.AgreementMajorVersion.DEPRECATED
+        )
+        return context
+
 
 class MemberAgreementList(AnVILConsortiumManagerViewRequired, SingleTableView):
     """Display a list of MemberAgreement objects."""
@@ -309,6 +331,14 @@ def get_object(self, queryset=None):
             )
         return obj
 
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_deprecation_message"] = (
+            self.object.signed_agreement.version.major_version.status
+            == models.AgreementMajorVersion.DEPRECATED
+        )
+        return context
+
 
 class DataAffiliateAgreementList(AnVILConsortiumManagerViewRequired, SingleTableView):
     """Display a list of DataAffiliateAgreement objects."""
@@ -351,6 +381,14 @@ def get_object(self, queryset=None):
             )
         return obj
 
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["show_deprecation_message"] = (
+            self.object.signed_agreement.version.major_version.status
+            == models.AgreementMajorVersion.DEPRECATED
+        )
+        return context
+
 
 class NonDataAffiliateAgreementList(
     AnVILConsortiumManagerViewRequired, SingleTableView
diff --git a/primed/templates/cdsa/agreementmajorversion_detail.html b/primed/templates/cdsa/agreementmajorversion_detail.html
index 2a8edd2a..b4ea6bef 100644
--- a/primed/templates/cdsa/agreementmajorversion_detail.html
+++ b/primed/templates/cdsa/agreementmajorversion_detail.html
@@ -3,9 +3,20 @@
 
 {% block title %}Agreement version v{{ object.version }}{% endblock %}
 
+{% block pills %}
+  {% if show_deprecation_message %}
+<span class="badge bg-danger">
+  <span class="fa-solid fa-skull-crossbones me-1"></span>
+  Deprecated
+</span>
+  {% endif %}
+{% endblock pills %}
+
 {% block panel %}
 <dl class="row">
   <dt class="col-sm-2">Version</dt> <dd class="col-sm-9"> v{{ object.version }}</dd>
+  <dt class="col-sm-2">Status</dt><dd class="col-sm-9"> {{ object.get_status_display }}</dd>
+  <dt class="col-sm-2">Date modified</dt><dd class="col-sm-9"> {{ object.modified }}</dd>
 </dl>
 {% endblock panel %}
 
@@ -13,6 +24,7 @@
 
 <h3>Agreement versions</h3>
 
+
 <div class="accordion my-3" id="accordionAgreementVersions">
   <div class="accordion-item">
     <h2 class="accordion-header" id="agreements-versions-heading">
diff --git a/primed/templates/cdsa/agreementversion_detail.html b/primed/templates/cdsa/agreementversion_detail.html
index fac00071..5db313cb 100644
--- a/primed/templates/cdsa/agreementversion_detail.html
+++ b/primed/templates/cdsa/agreementversion_detail.html
@@ -3,6 +3,15 @@
 
 {% block title %}Agreement version {{ object }}{% endblock %}
 
+{% block pills %}
+  {% if show_deprecation_message %}
+<span class="badge bg-danger">
+  <span class="fa-solid fa-skull-crossbones me-1"></span>
+  Deprecated
+</span>
+  {% endif %}
+{% endblock pills %}
+
 {% block panel %}
 <dl class="row">
   <dt class="col-sm-2">Full version</dt> <dd class="col-sm-9">{{ object.full_version }}</dd>
diff --git a/primed/templates/cdsa/dataaffiliateagreement_detail.html b/primed/templates/cdsa/dataaffiliateagreement_detail.html
index ab53eb35..e83ed685 100644
--- a/primed/templates/cdsa/dataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/dataaffiliateagreement_detail.html
@@ -1,6 +1,15 @@
 {% extends "anvil_consortium_manager/__object_detail.html" %}
 {% load django_tables2 %}
 
+{% block pills %}
+  {% if show_deprecation_message %}
+<span class="badge bg-danger">
+  <span class="fa-solid fa-skull-crossbones me-1"></span>
+  Deprecated CDSA version
+</span>
+  {% endif %}
+{% endblock pills %}
+
 {% block title %}Data affiliate agreement {{ object }}{% endblock %}
 
 {% block panel %}
diff --git a/primed/templates/cdsa/memberagreement_detail.html b/primed/templates/cdsa/memberagreement_detail.html
index 5c1b5d18..a74f006e 100644
--- a/primed/templates/cdsa/memberagreement_detail.html
+++ b/primed/templates/cdsa/memberagreement_detail.html
@@ -1,6 +1,15 @@
 {% extends "anvil_consortium_manager/__object_detail.html" %}
 {% load django_tables2 %}
 
+{% block pills %}
+  {% if show_deprecation_message %}
+<span class="badge bg-danger">
+  <span class="fa-solid fa-skull-crossbones me-1"></span>
+  Deprecated CDSA version
+</span>
+  {% endif %}
+{% endblock pills %}
+
 {% block title %}Member agreement {{ object }}{% endblock %}
 
 {% block panel %}
diff --git a/primed/templates/cdsa/nondataaffiliateagreement_detail.html b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
index b434ed02..3eea2fee 100644
--- a/primed/templates/cdsa/nondataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
@@ -1,6 +1,15 @@
 {% extends "anvil_consortium_manager/__object_detail.html" %}
 {% load django_tables2 %}
 
+{% block pills %}
+  {% if show_deprecation_message %}
+<span class="badge bg-danger">
+  <span class="fa-solid fa-skull-crossbones me-1"></span>
+  Deprecated CDSA version
+</span>
+  {% endif %}
+{% endblock pills %}
+
 {% block title %}Non-data affiliate agreement {{ object }}{% endblock %}
 
 {% block panel %}

From 936f325614bca428108e6dd93140b25fbf4508d5 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 13 Sep 2023 16:59:54 -0700
Subject: [PATCH 26/53] Use a boolean field for instead of a status field

We don't need the custom managers and overhead that comes along with
the StatusModel for AgreementMajorVersion, since we can't access the
model manager methods via the foreign key relationships and the
AgreementMajorVersion model is rarely used directly.
---
 primed/cdsa/admin.py                          |  6 ++--
 ...0008_agreementmajorversion_add_is_valid.py | 23 ++++++++++++
 .../0008_agreementmajorversion_add_status.py  | 35 ------------------
 primed/cdsa/models.py                         | 20 +++--------
 primed/cdsa/tables.py                         |  3 +-
 primed/cdsa/tests/test_models.py              | 10 ++----
 primed/cdsa/tests/test_views.py               | 36 ++++++++-----------
 primed/cdsa/views.py                          | 29 ++++++---------
 8 files changed, 61 insertions(+), 101 deletions(-)
 create mode 100644 primed/cdsa/migrations/0008_agreementmajorversion_add_is_valid.py
 delete mode 100644 primed/cdsa/migrations/0008_agreementmajorversion_add_status.py

diff --git a/primed/cdsa/admin.py b/primed/cdsa/admin.py
index a4beda1f..ff09f8ef 100644
--- a/primed/cdsa/admin.py
+++ b/primed/cdsa/admin.py
@@ -10,11 +10,11 @@ class AgreementMajorVersion(SimpleHistoryAdmin):
 
     list_display = (
         "version",
-        "status",
+        "is_valid",
     )
     list_filter = (
         "version",
-        "status",
+        "is_valid",
     )
     sortable_by = ("version",)
 
@@ -29,7 +29,7 @@ class AgreementVersion(SimpleHistoryAdmin):
     )
     list_filter = (
         "major_version",
-        "major_version__status",
+        "major_version__is_valid",
     )
     sortable_by = (
         "major_version",
diff --git a/primed/cdsa/migrations/0008_agreementmajorversion_add_is_valid.py b/primed/cdsa/migrations/0008_agreementmajorversion_add_is_valid.py
new file mode 100644
index 00000000..c315857c
--- /dev/null
+++ b/primed/cdsa/migrations/0008_agreementmajorversion_add_is_valid.py
@@ -0,0 +1,23 @@
+# Generated by Django 3.2.19 on 2023-09-13 23:43
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0007_alter_agreementversion_major_version'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='agreementmajorversion',
+            name='is_valid',
+            field=models.BooleanField(default=True, help_text='Boolean indicator of whether this version is valid.', verbose_name='Valid?'),
+        ),
+        migrations.AddField(
+            model_name='historicalagreementmajorversion',
+            name='is_valid',
+            field=models.BooleanField(default=True, help_text='Boolean indicator of whether this version is valid.', verbose_name='Valid?'),
+        ),
+    ]
diff --git a/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py b/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py
deleted file mode 100644
index 639b3b60..00000000
--- a/primed/cdsa/migrations/0008_agreementmajorversion_add_status.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Generated by Django 3.2.19 on 2023-09-13 22:48
-
-from django.db import migrations
-import django.utils.timezone
-import model_utils.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('cdsa', '0007_alter_agreementversion_major_version'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='agreementmajorversion',
-            name='status',
-            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='valid', max_length=100, no_check_for_status=True, verbose_name='status'),
-        ),
-        migrations.AddField(
-            model_name='agreementmajorversion',
-            name='status_changed',
-            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
-        ),
-        migrations.AddField(
-            model_name='historicalagreementmajorversion',
-            name='status',
-            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='valid', max_length=100, no_check_for_status=True, verbose_name='status'),
-        ),
-        migrations.AddField(
-            model_name='historicalagreementmajorversion',
-            name='status_changed',
-            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
-        ),
-    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 9331014a..3add774c 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -9,26 +9,13 @@
 from django.db import models
 from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
-from model_utils.models import StatusModel
 from simple_history.models import HistoricalRecords
 
 from primed.duo.models import DataUseOntologyModel
 from primed.primed_anvil.models import AvailableData, RequesterModel, Study, StudySite
 
 
-class AgreementMajorVersionStatusMixin:
-    # Workaround to use django-simple-history and django-model-utils StatusField together.
-    VALID = "valid"
-    DEPRECATED = "deprecated"
-    STATUS = (
-        (VALID, "Valid"),
-        (DEPRECATED, "Deprecated"),
-    )
-
-
-class AgreementMajorVersion(
-    TimeStampedModel, StatusModel, AgreementMajorVersionStatusMixin, models.Model
-):
+class AgreementMajorVersion(TimeStampedModel, models.Model):
     """A model for a major agreement version."""
 
     version = models.IntegerField(
@@ -36,8 +23,11 @@ class AgreementMajorVersion(
         validators=[MinValueValidator(1)],
         unique=True,
     )
+    is_valid = models.BooleanField(
+        default=True, help_text="Boolean indicator of whether this version is valid."
+    )
 
-    history = HistoricalRecords(bases=[AgreementMajorVersionStatusMixin, models.Model])
+    history = HistoricalRecords()
 
     def __str__(self):
         return "v{}".format(self.version)
diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 6873088b..95905e51 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -21,13 +21,14 @@ class AgreementVersionTable(tables.Table):
     full_version = tables.Column(
         linkify=True, order_by=("major_version", "minor_version")
     )
+    major_version__is_valid = BooleanCheckColumn(verbose_name="Valid?")
 
     class Meta:
         model = models.AgreementVersion
         fields = (
             "major_version",
             "full_version",
-            "major_version__status",
+            "major_version__is_valid",
             "date_approved",
         )
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 9a8e7407..9d6a8cce 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -31,15 +31,9 @@ def test_model_saving(self):
         instance.save()
         self.assertIsInstance(instance, models.AgreementMajorVersion)
 
-    def test_status_default(self):
+    def test_is_valid_default(self):
         instance = factories.AgreementMajorVersionFactory.create()
-        self.assertEqual(instance.status, models.AgreementMajorVersion.VALID)
-
-    def test_status_deprecated(self):
-        instance = factories.AgreementMajorVersionFactory.create(
-            status=models.AgreementMajorVersion.DEPRECATED
-        )
-        self.assertEqual(instance.status, models.AgreementMajorVersion.DEPRECATED)
+        self.assertTrue(instance.is_valid)
 
     def test_unique(self):
         factories.AgreementMajorVersionFactory.create(version=1)
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 153fb0f1..96df2265 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -243,9 +243,9 @@ def test_response_show_deprecation_message_valid(self):
         self.assertFalse(response.context_data["show_deprecation_message"])
         self.assertNotIn(b"Deprecated", response.content)
 
-    def test_response_show_deprecation_message_deprecated(self):
-        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
-        self.obj.status = self.obj.DEPRECATED
+    def test_response_show_deprecation_message_not_valid(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is is not valid."""
+        self.obj.is_valid = False
         self.obj.save()
         self.client.force_login(self.user)
         response = self.client.get(self.get_url(self.obj.version))
@@ -439,9 +439,9 @@ def test_response_show_deprecation_message_valid(self):
         self.assertFalse(response.context_data["show_deprecation_message"])
         self.assertNotIn(b"Deprecated", response.content)
 
-    def test_response_show_deprecation_message_deprecated(self):
-        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
-        self.obj.major_version.status = self.obj.major_version.DEPRECATED
+    def test_response_show_deprecation_message_not_valid(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is not valid."""
+        self.obj.major_version.is_valid = False
         self.obj.major_version.save()
         self.client.force_login(self.user)
         response = self.client.get(
@@ -1466,11 +1466,9 @@ def test_response_show_deprecation_message_valid(self):
         self.assertFalse(response.context_data["show_deprecation_message"])
         self.assertNotIn(b"Deprecated CDSA version", response.content)
 
-    def test_response_show_deprecation_message_deprecated(self):
-        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
-        self.obj.signed_agreement.version.major_version.status = (
-            models.AgreementMajorVersion.DEPRECATED
-        )
+    def test_response_show_deprecation_message_not_valid(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is not valid."""
+        self.obj.signed_agreement.version.major_version.is_valid = False
         self.obj.signed_agreement.version.major_version.save()
         self.client.force_login(self.user)
         response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
@@ -2642,11 +2640,9 @@ def test_response_show_deprecation_message_valid(self):
         self.assertFalse(response.context_data["show_deprecation_message"])
         self.assertNotIn(b"Deprecated CDSA version", response.content)
 
-    def test_response_show_deprecation_message_deprecated(self):
-        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
-        self.obj.signed_agreement.version.major_version.status = (
-            models.AgreementMajorVersion.DEPRECATED
-        )
+    def test_response_show_deprecation_message_not_valid(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is not valid."""
+        self.obj.signed_agreement.version.major_version.is_valid = False
         self.obj.signed_agreement.version.major_version.save()
         self.client.force_login(self.user)
         response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
@@ -3645,11 +3641,9 @@ def test_response_show_deprecation_message_valid(self):
         self.assertFalse(response.context_data["show_deprecation_message"])
         self.assertNotIn(b"Deprecated CDSA version", response.content)
 
-    def test_response_show_deprecation_message_deprecated(self):
-        """response context does show a deprecation warning when AgreementMajorVersion is deprecated."""
-        self.obj.signed_agreement.version.major_version.status = (
-            models.AgreementMajorVersion.DEPRECATED
-        )
+    def test_response_show_deprecation_message_is_not_valid(self):
+        """response context does show a deprecation warning when AgreementMajorVersion is not valid."""
+        self.obj.signed_agreement.version.major_version.is_valid = False
         self.obj.signed_agreement.version.major_version.save()
         self.client.force_login(self.user)
         response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 651e9591..d64fcc12 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -56,9 +56,7 @@ def get_tables_data(self):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["show_deprecation_message"] = (
-            self.object.status == self.object.DEPRECATED
-        )
+        context["show_deprecation_message"] = not self.object.is_valid
         return context
 
 
@@ -94,9 +92,7 @@ def get_object(self, queryset=None):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["show_deprecation_message"] = (
-            self.object.major_version.status == self.object.major_version.DEPRECATED
-        )
+        context["show_deprecation_message"] = not self.object.major_version.is_valid
         return context
 
 
@@ -300,10 +296,9 @@ def get_object(self, queryset=None):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["show_deprecation_message"] = (
-            self.object.signed_agreement.version.major_version.status
-            == models.AgreementMajorVersion.DEPRECATED
-        )
+        context[
+            "show_deprecation_message"
+        ] = not self.object.signed_agreement.version.major_version.is_valid
         return context
 
 
@@ -333,10 +328,9 @@ def get_object(self, queryset=None):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["show_deprecation_message"] = (
-            self.object.signed_agreement.version.major_version.status
-            == models.AgreementMajorVersion.DEPRECATED
-        )
+        context[
+            "show_deprecation_message"
+        ] = not self.object.signed_agreement.version.major_version.is_valid
         return context
 
 
@@ -383,10 +377,9 @@ def get_object(self, queryset=None):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["show_deprecation_message"] = (
-            self.object.signed_agreement.version.major_version.status
-            == models.AgreementMajorVersion.DEPRECATED
-        )
+        context[
+            "show_deprecation_message"
+        ] = not self.object.signed_agreement.version.major_version.is_valid
         return context
 
 

From b45f27df63052b3885154858c1e1dcfaa4cca6d5 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 14 Sep 2023 11:09:41 -0700
Subject: [PATCH 27/53] Add keyword to specify if False icons should be shown

Rename BooleanCheckColumn to BooleanIconColumn, which is a more
representative of what the column is now doing. Add an init argument
that allows the user to specify if they would like icons to be
displayed for "False" values. For the AgreementVersionTable, show
the false icon.
---
 primed/cdsa/tables.py                    | 12 +++++-----
 primed/primed_anvil/tables.py            | 25 ++++++++++++---------
 primed/primed_anvil/tests/test_tables.py | 28 ++++++++++++++++++------
 3 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 95905e51..41eb29a3 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -8,7 +8,7 @@
 )
 
 from primed.primed_anvil.tables import (
-    BooleanCheckColumn,
+    BooleanIconColumn,
     WorkspaceSharedWithConsortiumTable,
 )
 
@@ -21,7 +21,9 @@ class AgreementVersionTable(tables.Table):
     full_version = tables.Column(
         linkify=True, order_by=("major_version", "minor_version")
     )
-    major_version__is_valid = BooleanCheckColumn(verbose_name="Valid?")
+    major_version__is_valid = BooleanIconColumn(
+        verbose_name="Valid?", show_false_icon=True
+    )
 
     class Meta:
         model = models.AgreementVersion
@@ -75,7 +77,7 @@ class MemberAgreementTable(tables.Table):
 
     signed_agreement__cc_id = tables.Column(linkify=True)
     study_site = tables.Column(linkify=True)
-    signed_agreement__is_primary = BooleanCheckColumn(verbose_name="Primary?")
+    signed_agreement__is_primary = BooleanIconColumn(verbose_name="Primary?")
     signed_agreement__representative__name = tables.Column(
         linkify=lambda record: record.signed_agreement.representative.get_absolute_url(),
         verbose_name="Representative",
@@ -107,7 +109,7 @@ class DataAffiliateAgreementTable(tables.Table):
 
     signed_agreement__cc_id = tables.Column(linkify=True)
     study = tables.Column(linkify=True)
-    signed_agreement__is_primary = BooleanCheckColumn(verbose_name="Primary?")
+    signed_agreement__is_primary = BooleanIconColumn(verbose_name="Primary?")
     signed_agreement__representative__name = tables.Column(
         linkify=lambda record: record.signed_agreement.representative.get_absolute_url(),
         verbose_name="Representative",
@@ -138,7 +140,7 @@ class NonDataAffiliateAgreementTable(tables.Table):
     """Table to display `DataAffiliateAgreement` objects."""
 
     signed_agreement__cc_id = tables.Column(linkify=True)
-    signed_agreement__is_primary = BooleanCheckColumn()
+    signed_agreement__is_primary = BooleanIconColumn()
     signed_agreement__representative__name = tables.Column(
         linkify=lambda record: record.signed_agreement.representative.get_absolute_url(),
         verbose_name="Representative",
diff --git a/primed/primed_anvil/tables.py b/primed/primed_anvil/tables.py
index cfda4c5e..58072585 100644
--- a/primed/primed_anvil/tables.py
+++ b/primed/primed_anvil/tables.py
@@ -5,24 +5,29 @@
 from . import models
 
 
-class BooleanCheckColumn(tables.BooleanColumn):
+class BooleanIconColumn(tables.BooleanColumn):
 
     #    attrs = {"td": {"align": "center"}}
     # attrs = {"th": {"class": "center"}}
 
+    def __init__(self, show_false_icon=False, **kwargs):
+        super().__init__(**kwargs)
+        self.show_false_icon = show_false_icon
+
     def render(self, value, record, bound_column):
         value = self._get_bool_value(record, value, bound_column)
         if value:
-            icon = "check-circle-fill"
-            color = "green"
-            value = format_html(
-                """<i class="bi bi-{} bi-align-center px-2" style="color: {};"></i>""".format(
-                    icon, color
-                )
+            rendered_value = format_html(
+                """<i class="bi bi-check-circle-fill bi-align-center px-2" style="color: green;"></i>"""
             )
         else:
-            value = ""
-        return value
+            if self.show_false_icon:
+                rendered_value = format_html(
+                    """<i class="bi bi-x-circle-fill bi-align-center px-2" style="color: red;"></i>"""
+                )
+            else:
+                rendered_value = ""
+        return rendered_value
 
 
 class WorkspaceSharedWithConsortiumTable(tables.Table):
@@ -131,6 +136,6 @@ def __init__(self, *args, **kwargs):
             "name", flat=True
         )
         extra_columns = [
-            (x, BooleanCheckColumn(default=False)) for x in available_data_types
+            (x, BooleanIconColumn(default=False)) for x in available_data_types
         ]
         super().__init__(*args, extra_columns=extra_columns, **kwargs)
diff --git a/primed/primed_anvil/tests/test_tables.py b/primed/primed_anvil/tests/test_tables.py
index 0345e773..5d42cb82 100644
--- a/primed/primed_anvil/tests/test_tables.py
+++ b/primed/primed_anvil/tests/test_tables.py
@@ -138,10 +138,24 @@ def test_adds_two_available_data_column(self):
         self.assertEqual(table.columns[4].name, "Foo")
 
 
-class BooleanCheckColumnTest(TestCase):
-    def test_render_available_data(self):
-        factories.AvailableDataFactory.create(name="Foo")
-        self.assertIn(
-            "bi-check-circle-fill", tables.BooleanCheckColumn().render(True, None, None)
-        )
-        self.assertEqual(tables.BooleanCheckColumn().render(False, None, None), "")
+class BooleanIconColumnTest(TestCase):
+    """Tests for the BooleanIconColumn class."""
+
+    def test_render_default(self):
+        """render method with defaults."""
+        column = tables.BooleanIconColumn()
+        value = column.render(True, None, None)
+        self.assertIn("bi-check-circle-fill", value)
+        self.assertIn("green", value)
+        value = column.render(False, None, None)
+        self.assertEqual(value, "")
+
+    def test_render_show_false_icon(self):
+        """render method with defaults."""
+        column = tables.BooleanIconColumn(show_false_icon=True)
+        value = column.render(True, None, None)
+        self.assertIn("bi-check-circle-fill", value)
+        self.assertIn("green", value)
+        value = column.render(False, None, None)
+        self.assertIn("bi-x-circle-fill", value)
+        self.assertIn("red", value)

From df5eca08a7de24476ae34668762abc9589750217 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 14 Sep 2023 14:51:56 -0700
Subject: [PATCH 28/53] Only allow valid AgreementVersions to be selected for
 SignedAgreements

Modify the SignedAgreementForm version queryset to include only
AgreementVersions whose major version is valid. Add a test to check
this.
---
 primed/cdsa/forms.py            |  3 +++
 primed/cdsa/tests/test_forms.py | 20 ++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/primed/cdsa/forms.py b/primed/cdsa/forms.py
index dde759cd..f3820344 100644
--- a/primed/cdsa/forms.py
+++ b/primed/cdsa/forms.py
@@ -19,6 +19,9 @@ class SignedAgreementForm(Bootstrap5MediaFormMixin, forms.ModelForm):
         widget=forms.RadioSelect,
         label="Agreement type",
     )
+    version = forms.ModelChoiceField(
+        queryset=models.AgreementVersion.objects.filter(major_version__is_valid=True)
+    )
 
     class Meta:
         model = models.SignedAgreement
diff --git a/primed/cdsa/tests/test_forms.py b/primed/cdsa/tests/test_forms.py
index 1366efc2..7b191e34 100644
--- a/primed/cdsa/tests/test_forms.py
+++ b/primed/cdsa/tests/test_forms.py
@@ -202,6 +202,26 @@ def test_invalid_duplicate_object(self):
         self.assertEqual(len(form.errors["cc_id"]), 1)
         self.assertIn("already exists", form.errors["cc_id"][0])
 
+    def test_invalid_version(self):
+        """Cannot select an AgreementVersion that is not valid."""
+        self.agreement_version.major_version.is_valid = False
+        self.agreement_version.major_version.save()
+        form_data = {
+            "cc_id": 1234,
+            "representative": self.representative,
+            "representative_role": "Test role",
+            "signing_institution": "Test insitution",
+            "version": self.agreement_version,
+            "date_signed": "2023-01-01",
+            "is_primary": True,
+        }
+        form = self.form_class(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("version", form.errors)
+        self.assertEqual(len(form.errors["version"]), 1)
+        self.assertIn("valid choice", form.errors["version"][0])
+
 
 class MemberAgreementFormTest(TestCase):
     """Tests for the MemberAgreementForm class."""

From 20f52aac07fb90511229aabb2a3c2f7737067e1e Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Thu, 14 Sep 2023 14:54:55 -0700
Subject: [PATCH 29/53] Add version to the RepresentativeRecords table

---
 primed/cdsa/tables.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index 41eb29a3..ae3c6b40 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -182,6 +182,8 @@ class Meta:
             "representative_role",
             "signing_institution",
             "signing_group",
+            "agreement_type",
+            "version",
         )
 
     def render_signing_group(self, record):

From a0e14526228d20cf3d8bdd268bd70a7fa0e7d632 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 15 Sep 2023 15:28:12 -0700
Subject: [PATCH 30/53] Add method to check if a signed agreement is in the
 CDSA group

---
 primed/cdsa/models.py            | 13 +++++++++++-
 primed/cdsa/tests/test_models.py | 35 +++++++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 3add774c..ac972da7 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -2,7 +2,11 @@
 
 from datetime import date
 
-from anvil_consortium_manager.models import BaseWorkspaceData, ManagedGroup
+from anvil_consortium_manager.models import (
+    BaseWorkspaceData,
+    GroupGroupMembership,
+    ManagedGroup,
+)
 from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
@@ -180,6 +184,13 @@ def get_agreement_type(self):
     def agreement_group(self):
         return self.get_agreement_type().get_agreement_group()
 
+    def is_in_cdsa_group(self):
+        anvil_cdsa_group = ManagedGroup.objects.get(name=settings.ANVIL_CDSA_GROUP_NAME)
+        return GroupGroupMembership.objects.filter(
+            parent_group=anvil_cdsa_group,
+            child_group=self.anvil_access_group,
+        ).exists()
+
 
 class AgreementTypeModel(models.Model):
     """An abstract model that can be used to provide required fields for agreement type models."""
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 9d6a8cce..61e62812 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -2,14 +2,16 @@
 
 from datetime import datetime
 
+from anvil_consortium_manager.models import ManagedGroup
 from anvil_consortium_manager.tests.factories import (
+    GroupGroupMembershipFactory,
     ManagedGroupFactory,
     WorkspaceFactory,
 )
 from django.core.exceptions import NON_FIELD_ERRORS, ValidationError
 from django.db.models import ProtectedError
 from django.db.utils import IntegrityError
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 from primed.duo.tests.factories import DataUseModifierFactory, DataUsePermissionFactory
 from primed.primed_anvil.tests.factories import (
@@ -341,6 +343,37 @@ def test_clean_non_data_affiliate_is_primary_false(self):
         self.assertEqual(len(e.exception.message_dict[NON_FIELD_ERRORS]), 1)
         self.assertIn("primary", e.exception.message_dict[NON_FIELD_ERRORS][0])
 
+    def test_is_in_cdsa_group(self):
+        """is_in_cdsa_group works as expected."""
+        obj = factories.SignedAgreementFactory.create()
+        # When group does not exist
+        with self.assertRaises(ManagedGroup.DoesNotExist):
+            obj.is_in_cdsa_group()
+        # Create group, without adding agreement
+        cdsa_group = ManagedGroupFactory.create(name="TEST_PRIMED_CDSA")
+        self.assertFalse(obj.is_in_cdsa_group())
+        # Add agreement and check again,
+        GroupGroupMembershipFactory.create(
+            parent_group=cdsa_group, child_group=obj.anvil_access_group
+        )
+        self.assertTrue(obj.is_in_cdsa_group())
+
+    @override_settings(ANVIL_CDSA_GROUP_NAME="FOO")
+    def test_is_in_cdsa_group_different_group_name(self):
+        """is_in_cdsa_group works as expected."""
+        obj = factories.SignedAgreementFactory.create()
+        # When group does not exist
+        with self.assertRaises(ManagedGroup.DoesNotExist):
+            obj.is_in_cdsa_group()
+        # Create group, without adding agreement
+        cdsa_group = ManagedGroupFactory.create(name="FOO")
+        self.assertFalse(obj.is_in_cdsa_group())
+        # Add agreement and check again,
+        GroupGroupMembershipFactory.create(
+            parent_group=cdsa_group, child_group=obj.anvil_access_group
+        )
+        self.assertTrue(obj.is_in_cdsa_group())
+
 
 class MemberAgreementTest(TestCase):
     """Tests for the MemberAgremeent model."""

From 7882302ea747d5000dac8a795a8ccbb1275c3966 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 15 Sep 2023 16:22:17 -0700
Subject: [PATCH 31/53] Update SignedAgreementAudit to handle invalid major
 versions

This update also refactored the code and the tests quite a bit,
which makes it a little easier to read (hopefully). Add more tests.
---
 primed/cdsa/audit/signed_agreement_audit.py |  227 +++--
 primed/cdsa/tests/test_audit.py             | 1021 +++++++++++++++++--
 primed/cdsa/tests/test_views.py             |   10 +-
 primed/cdsa/views.py                        |   18 +-
 4 files changed, 1099 insertions(+), 177 deletions(-)

diff --git a/primed/cdsa/audit/signed_agreement_audit.py b/primed/cdsa/audit/signed_agreement_audit.py
index a1ad81f2..9a9ab47d 100644
--- a/primed/cdsa/audit/signed_agreement_audit.py
+++ b/primed/cdsa/audit/signed_agreement_audit.py
@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 
 import django_tables2 as tables
-from anvil_consortium_manager.models import GroupGroupMembership, ManagedGroup
+from anvil_consortium_manager.models import ManagedGroup
 from django.conf import settings
 from django.urls import reverse
 from django.utils.safestring import mark_safe
@@ -126,118 +126,205 @@ class SignedAgreementAccessAudit:
     """Audit for Signed Agreements."""
 
     # Access verified.
-    VALID_PRIMARY_CDSA = "Valid primary CDSA."
-    VALID_COMPONENT_CDSA = "Valid component CDSA."
+    VALID_PRIMARY_AGREEMENT = "Valid primary CDSA."
+    VALID_COMPONENT_AGREEMENT = "Valid component CDSA."
 
     # Allowed reasons for no access.
-    NO_PRIMARY_CDSA = "No primary CDSA for this group exists."
+    NO_PRIMARY_AGREEMENT = "No valid primary CDSA for this group exists."
+    PRIMARY_NOT_VALID = "Primary agreement for this CDSA is not valid."
+    INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
 
     # Other errors
+    ERROR_NON_DATA_AFFILIATE_COMPONENT = (
+        "Non-data affiliate agreements must be primary."
+    )
     ERROR_OTHER_CASE = "Signed Agreement did not match any expected situations."
 
     results_table_class = SignedAgreementAccessAuditTable
 
     def __init__(self):
         # Store the CDSA group for auditing membership.
-        self.anvil_cdsa_group = ManagedGroup.objects.get(
-            name=settings.ANVIL_CDSA_GROUP_NAME
-        )
         self.completed = False
         # Set up lists to hold audit results.
         self.verified = []
         self.needs_action = []
         self.errors = []
 
-    # Audit a single signed agreement.
-    def _audit_signed_agreement(self, signed_agreement):
-        # Check if the access group is in the overall CDSA group.
-        in_cdsa_group = GroupGroupMembership.objects.filter(
-            parent_group=self.anvil_cdsa_group,
-            child_group=signed_agreement.anvil_access_group,
-        ).exists()
-        # Primary agreements don't need to check components.
-        if signed_agreement.is_primary and in_cdsa_group:
-            self.verified.append(
-                VerifiedAccess(
-                    signed_agreement=signed_agreement,
-                    note=self.VALID_PRIMARY_CDSA,
-                )
-            )
-            return
-        elif signed_agreement.is_primary and not in_cdsa_group:
-            self.needs_action.append(
-                GrantAccess(
-                    signed_agreement=signed_agreement,
-                    note=self.VALID_PRIMARY_CDSA,
-                )
-            )
-            return
-        elif not signed_agreement.is_primary:
-            # component agreements need to check for a primary.
-            if hasattr(signed_agreement, "memberagreement"):
-                # Member
-                primary_exists = models.MemberAgreement.objects.filter(
-                    signed_agreement__is_primary=True,
-                    study_site=signed_agreement.memberagreement.study_site,
-                ).exists()
-            elif hasattr(signed_agreement, "dataaffiliateagreement"):
-                # Data affiliate
-                primary_exists = models.DataAffiliateAgreement.objects.filter(
-                    signed_agreement__is_primary=True,
-                    study=signed_agreement.dataaffiliateagreement.study,
-                ).exists()
-            elif hasattr(signed_agreement, "nondataaffiliateagreement"):
-                # Non-data affiliate should not have components so this is an error.
-                raise RuntimeError(
-                    "Non data affiliates should always be a primary CDSA."
-                )
-            else:
-                # Some other case happened - log it as an error.
-                self.errors.append(
-                    OtherError(
-                        signed_agreement=signed_agreement, note=self.ERROR_OTHER_CASE
-                    )
-                )
-                return
+    def _audit_primary_agreement(self, signed_agreement):
+        """Audit a single component signed agreement.
+
+        The following items are checked:
+        * if the primary agreement is valid.
+        * if the primary agreement is in the CDSA group.
+        """
+        is_valid = signed_agreement.version.major_version.is_valid
+        in_cdsa_group = signed_agreement.is_in_cdsa_group()
 
-            # Now check access for the component given the primary agreement.
-            if primary_exists and in_cdsa_group:
+        if is_valid:
+            if in_cdsa_group:
                 self.verified.append(
                     VerifiedAccess(
                         signed_agreement=signed_agreement,
-                        note=self.VALID_COMPONENT_CDSA,
+                        note=self.VALID_PRIMARY_AGREEMENT,
                     )
                 )
                 return
-            elif primary_exists and not in_cdsa_group:
+            else:
                 self.needs_action.append(
                     GrantAccess(
                         signed_agreement=signed_agreement,
-                        note=self.VALID_COMPONENT_CDSA,
+                        note=self.VALID_PRIMARY_AGREEMENT,
                     )
                 )
                 return
-            elif not primary_exists and not in_cdsa_group:
+        else:
+            if in_cdsa_group:
+                self.needs_action.append(
+                    RemoveAccess(
+                        signed_agreement=signed_agreement,
+                        note=self.INVALID_AGREEMENT_VERSION,
+                    )
+                )
+                return
+            else:
                 self.verified.append(
                     VerifiedNoAccess(
                         signed_agreement=signed_agreement,
-                        note=self.NO_PRIMARY_CDSA,
+                        note=self.INVALID_AGREEMENT_VERSION,
                     )
                 )
                 return
-            elif not primary_exists and in_cdsa_group:
+
+        # If we made it this far in audit, some other case happened - log it as an error.
+        # Haven't figured out a test for this because it is unexpected.
+        self.errors.append(  # pragma: no cover
+            OtherError(
+                signed_agreement=signed_agreement, note=self.ERROR_OTHER_CASE
+            )  # pragma: no cover
+        )  # pragma: no cover
+
+    def _audit_component_agreement(self, signed_agreement):
+        """Audit a single component signed agreement.
+
+        The following items are checked:
+        * If a primary agreement exists.
+        * if the component agreement is valid.
+        * if the corresponding primary is invalid.
+        * if the component agreement is in the CDSA group.
+        """
+        is_valid = signed_agreement.version.major_version.is_valid
+        in_cdsa_group = signed_agreement.is_in_cdsa_group()
+
+        # Get the set of potential primary agreements for this component.
+        if hasattr(signed_agreement, "memberagreement"):
+            # Member
+            primary_qs = models.SignedAgreement.objects.filter(
+                is_primary=True,
+                memberagreement__study_site=signed_agreement.memberagreement.study_site,
+            )
+        elif hasattr(signed_agreement, "dataaffiliateagreement"):
+            # Data affiliate
+            primary_qs = models.SignedAgreement.objects.filter(
+                is_primary=True,
+                dataaffiliateagreement__study=signed_agreement.dataaffiliateagreement.study,
+            )
+        elif hasattr(signed_agreement, "nondataaffiliateagreement"):
+            self.errors.append(
+                OtherError(
+                    signed_agreement=signed_agreement,
+                    note=self.ERROR_NON_DATA_AFFILIATE_COMPONENT,
+                )
+            )
+            return
+        primary_exists = primary_qs.exists()
+        primary_valid = primary_qs.filter(
+            version__major_version__is_valid=True
+        ).exists()
+
+        if primary_exists:
+            if is_valid:
+                if primary_valid:
+                    if in_cdsa_group:
+                        self.verified.append(
+                            VerifiedAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.VALID_COMPONENT_AGREEMENT,
+                            )
+                        )
+                        return
+                    else:
+                        self.needs_action.append(
+                            GrantAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.VALID_COMPONENT_AGREEMENT,
+                            )
+                        )
+                        return
+                else:
+                    if in_cdsa_group:
+                        self.needs_action.append(
+                            RemoveAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.PRIMARY_NOT_VALID,
+                            )
+                        )
+                        return
+                    else:
+                        self.verified.append(
+                            VerifiedNoAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.PRIMARY_NOT_VALID,
+                            )
+                        )
+                        return
+            else:
+                if in_cdsa_group:
+                    self.needs_action.append(
+                        RemoveAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.INVALID_AGREEMENT_VERSION,
+                        )
+                    )
+                    return
+                else:
+                    self.verified.append(
+                        VerifiedNoAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.INVALID_AGREEMENT_VERSION,
+                        )
+                    )
+                    return
+        else:
+            if in_cdsa_group:
                 self.errors.append(
                     RemoveAccess(
                         signed_agreement=signed_agreement,
-                        note=self.NO_PRIMARY_CDSA,
+                        note=self.NO_PRIMARY_AGREEMENT,
+                    )
+                )
+                return
+            else:
+                self.verified.append(
+                    VerifiedNoAccess(
+                        signed_agreement=signed_agreement,
+                        note=self.NO_PRIMARY_AGREEMENT,
                     )
                 )
                 return
 
         # If we made it this far in audit, some other case happened - log it as an error.
-        self.errors.append(
-            OtherError(signed_agreement=signed_agreement, note=self.ERROR_OTHER_CASE)
-        )
+        # Haven't figured out a test for this because it is unexpected.
+        self.errors.append(  # pragma: no cover
+            OtherError(
+                signed_agreement=signed_agreement, note=self.ERROR_OTHER_CASE
+            )  # pragma: no cover
+        )  # pragma: no cover
+
+    def _audit_signed_agreement(self, signed_agreement):
+        if signed_agreement.is_primary:
+            self._audit_primary_agreement(signed_agreement)
+        else:
+            self._audit_component_agreement(signed_agreement)
 
     def run_audit(self):
         """Run an audit on all SignedAgreements."""
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 641e91af..1edad70a 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -117,222 +117,1057 @@ def test_no_signed_agreements(self):
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
 
-    def test_one_signed_agreement_primary_verified_access(self):
-        signed_agreement = factories.SignedAgreementFactory.create()
+    def test_loops_over_signed_agreements(self):
+        """run_audit loops over all signed agreements."""
+        # Create two signed agreements that need to be added to the SAG group.
+        factories.MemberAgreementFactory.create_batch(2)
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit.run_audit()
+        self.assertEqual(len(cdsa_audit.needs_action), 2)
+
+    # def test_one_signed_agreement_primary_verified_access(self):
+    #     signed_agreement = factories.SignedAgreementFactory.create()
+    #     # Add the signed agreement access group to the CDSA group.
+    #     GroupGroupMembershipFactory.create(
+    #         parent_group=self.cdsa_group,
+    #         child_group=signed_agreement.anvil_access_group,
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit.run_audit()
+    #     self.assertEqual(len(cdsa_audit.verified), 1)
+    #     record = cdsa_audit.verified[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+    #     self.assertEqual(record.signed_agreement, signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_primary_needs_access(self):
+    #     signed_agreement = factories.SignedAgreementFactory.create()
+    #     # Do not add the signed agreement access group to the CDSA group.
+    #     # GroupGroupMembershipFactory.create(
+    #     #     parent_group=self.cdsa_group, child_group=signed_agreement.anvil_access_group
+    #     # )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit.run_audit()
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
+    #     record = cdsa_audit.needs_action[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+    #     self.assertEqual(record.signed_agreement, signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_member_component_verified_access(self):
+    #     study_site = StudySiteFactory.create()
+    #     factories.MemberAgreementFactory.create(study_site=study_site)
+    #     component_agreement = factories.MemberAgreementFactory.create(
+    #         signed_agreement__is_primary=False, study_site=study_site
+    #     )
+    #     # Add the component agreement access group to the CDSA group.
+    #     GroupGroupMembershipFactory.create(
+    #         parent_group=self.cdsa_group,
+    #         child_group=component_agreement.signed_agreement.anvil_access_group,
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 1)
+    #     record = cdsa_audit.verified[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_member_component_no_primary_no_access(self):
+    #     component_agreement = factories.MemberAgreementFactory.create(
+    #         signed_agreement__is_primary=False
+    #     )
+    #     # Do not add the component agreement access group to the CDSA group.
+    #     # GroupGroupMembershipFactory.create(
+    #     #     parent_group=self.cdsa_group,
+    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
+    #     # )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 1)
+    #     record = cdsa_audit.verified[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_member_component_needs_access(self):
+    #     study_site = StudySiteFactory.create()
+    #     factories.MemberAgreementFactory.create(study_site=study_site)
+    #     component_agreement = factories.MemberAgreementFactory.create(
+    #         signed_agreement__is_primary=False, study_site=study_site
+    #     )
+    #     # Do not add the component agreement access group to the CDSA group.
+    #     # GroupGroupMembershipFactory.create(
+    #     #     parent_group=self.cdsa_group,
+    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
+    #     # )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
+    #     record = cdsa_audit.needs_action[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_member_component_error(self):
+    #     # No primary, but the agreement has access (incorrectly).
+    #     component_agreement = factories.MemberAgreementFactory.create(
+    #         signed_agreement__is_primary=False
+    #     )
+    #     # Add the component agreement access group to the CDSA group (to trip the error).
+    #     GroupGroupMembershipFactory.create(
+    #         parent_group=self.cdsa_group,
+    #         child_group=component_agreement.signed_agreement.anvil_access_group,
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 1)
+    #     record = cdsa_audit.errors[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+
+    # def test_one_signed_agreement_data_affiliate_component_verified_access(self):
+    #     study = StudyFactory.create()
+    #     factories.DataAffiliateAgreementFactory.create(study=study)
+    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
+    #         signed_agreement__is_primary=False, study=study
+    #     )
+    #     # Add the component agreement access group to the CDSA group.
+    #     GroupGroupMembershipFactory.create(
+    #         parent_group=self.cdsa_group,
+    #         child_group=component_agreement.signed_agreement.anvil_access_group,
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 1)
+    #     record = cdsa_audit.verified[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_data_affiliate_component_no_primary_no_access(self):
+    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
+    #         signed_agreement__is_primary=False
+    #     )
+    #     # Do not add the component agreement access group to the CDSA group.
+    #     # GroupGroupMembershipFactory.create(
+    #     #     parent_group=self.cdsa_group,
+    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
+    #     # )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 1)
+    #     record = cdsa_audit.verified[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_data_affiliate_component_needs_access(self):
+    #     study = StudyFactory.create()
+    #     factories.DataAffiliateAgreementFactory.create(study=study)
+    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
+    #         signed_agreement__is_primary=False, study=study
+    #     )
+    #     # Do not add the component agreement access group to the CDSA group.
+    #     # GroupGroupMembershipFactory.create(
+    #     #     parent_group=self.cdsa_group,
+    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
+    #     # )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
+    #     record = cdsa_audit.needs_action[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+    #     self.assertEqual(len(cdsa_audit.errors), 0)
+
+    # def test_one_signed_agreement_data_affiliate_component_needs_error(self):
+    #     # No primary, but the agreement has access (incorrectly).
+    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
+    #         signed_agreement__is_primary=False
+    #     )
+    #     # Add the component agreement access group to the CDSA group (to trip the error).
+    #     GroupGroupMembershipFactory.create(
+    #         parent_group=self.cdsa_group,
+    #         child_group=component_agreement.signed_agreement.anvil_access_group,
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 1)
+    #     record = cdsa_audit.errors[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+
+    # def test_one_signed_agreement_nondataaffiliate_component(self):
+    #     factories.NonDataAffiliateAgreementFactory.create(
+    #         signed_agreement__is_primary=False
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     with self.assertRaises(RuntimeError):
+    #         cdsa_audit.run_audit()
+
+    # def test_other_error(self):
+    #     signed_agreement = factories.SignedAgreementFactory.create(
+    #         is_primary=False, type="MEMBER"
+    #     )
+    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+    #     cdsa_audit._audit_signed_agreement(signed_agreement)
+    #     self.assertEqual(len(cdsa_audit.verified), 0)
+    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
+    #     self.assertEqual(len(cdsa_audit.errors), 1)
+    #     record = cdsa_audit.errors[0]
+    #     self.assertIsInstance(record, signed_agreement_audit.OtherError)
+    #     self.assertEqual(record.signed_agreement, signed_agreement)
+    #     self.assertEqual(record.note, cdsa_audit.ERROR_OTHER_CASE)
+
+    # New tests
+    def test_member_primary_in_group(self):
+        """Member primary agreement with valid version in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create()
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
             parent_group=self.cdsa_group,
-            child_group=signed_agreement.anvil_access_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 1)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-        self.assertEqual(record.signed_agreement, signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
 
-    def test_one_signed_agreement_primary_needs_access(self):
-        signed_agreement = factories.SignedAgreementFactory.create()
+    def test_member_primary_not_in_group(self):
+        """Member primary agreement with valid version not in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create()
         # Do not add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
-        #     parent_group=self.cdsa_group, child_group=signed_agreement.anvil_access_group
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-        self.assertEqual(record.signed_agreement, signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_member_primary_invalid_version_in_group(self):
+        """Member primary agreement with invalid version in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_member_primary_invalid_version_not_in_group(self):
+        """Member primary agreement, with invalid version, not in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
-    def test_one_signed_agreement_member_component_verified_access(self):
+    def test_member_component_has_primary_in_group(self):
+        """Member component agreement, with valid version, with primary with valid version, in CDSA group."""
         study_site = StudySiteFactory.create()
         factories.MemberAgreementFactory.create(study_site=study_site)
-        component_agreement = factories.MemberAgreementFactory.create(
+        this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False, study_site=study_site
         )
-        # Add the component agreement access group to the CDSA group.
+        # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
             parent_group=self.cdsa_group,
-            child_group=component_agreement.signed_agreement.anvil_access_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+
+    def test_member_component_has_primary_not_in_group(self):
+        """Member component agreement, with valid version, with primary with valid version, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
 
-    def test_one_signed_agreement_member_component_no_primary_no_access(self):
-        component_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__is_primary=False
+    def test_member_component_has_primary_with_invalid_version_in_group(self):
+        """Member component agreement, with valid version, with primary with invalid version, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
         )
-        # Do not add the component agreement access group to the CDSA group.
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
+    def test_member_component_has_primary_with_invalid_version_not_in_group(self):
+        """Member component agreement, with valid version, with primary with invalid version, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
+        )
+        # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
         #     parent_group=self.cdsa_group,
-        #     child_group=component_agreement.signed_agreement.anvil_access_group
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
+    def test_member_component_no_primary_in_group(self):
+        """Member component agreement, with valid version, with no primary, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
-        self.assertEqual(len(cdsa_audit.errors), 0)
+        self.assertEqual(len(cdsa_audit.errors), 1)
+        record = cdsa_audit.errors[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
-    def test_one_signed_agreement_member_component_needs_access(self):
+    def test_member_component_no_primary_not_in_group(self):
+        """Member component agreement, with valid version, with no primary, not in CDSA group."""
         study_site = StudySiteFactory.create()
-        factories.MemberAgreementFactory.create(study_site=study_site)
-        component_agreement = factories.MemberAgreementFactory.create(
+        this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False, study_site=study_site
         )
-        # Do not add the component agreement access group to the CDSA group.
+        # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
         #     parent_group=self.cdsa_group,
-        #     child_group=component_agreement.signed_agreement.anvil_access_group
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_member_component_invalid_version_has_primary_in_group(self):
+        """Member component agreement, with invalid version, with a valid primary, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_member_component_invalid_version_has_primary_not_in_group(self):
+        """Member component agreement, with invalid version, with a valid primary, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
-    def test_one_signed_agreement_member_component_needs_error(self):
-        # No primary, but the agreement has access (incorrectly).
-        component_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__is_primary=False
+    def test_member_component_invalid_version_has_primary_with_invalid_version_in_group(
+        self,
+    ):
+        """Member component agreement, with invalid version, with an invalid primary, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_member_component_invalid_version_has_primary_with_invalid_version_not_in_group(
+        self,
+    ):
+        """Member component agreement, with invalid version, with an invalid primary, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_member_component_invalid_version_no_primary_in_group(self):
+        """Member component agreement, with invalid version, with no primary, in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            signed_agreement__version__major_version__is_valid=False,
         )
-        # Add the component agreement access group to the CDSA group (to trip the error).
+        # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
             parent_group=self.cdsa_group,
-            child_group=component_agreement.signed_agreement.anvil_access_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 1)
         record = cdsa_audit.errors[0]
         self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_member_component_invalid_version_no_primary_not_in_group(self):
+        """Member component agreement, with invalid version, with no primary, not in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_data_affiliate_primary_in_group(self):
+        """Data affiliate primary agreement with valid version in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create()
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_data_affiliate_primary_not_in_group(self):
+        """Data affiliate primary agreement with valid version not in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create()
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_data_affiliate_primary_invalid_version_in_group(self):
+        """Data affiliate primary agreement with invalid version in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
-    def test_one_signed_agreement_data_affiliate_component_verified_access(self):
+    def test_data_affiliate_primary_invalid_version_not_in_group(self):
+        """Data affiliate primary agreement, with invalid version, not in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_data_affiliate_component_has_primary_in_group(self):
+        """Data affiliate component agreement, with valid version, with primary with valid version, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
-        component_agreement = factories.DataAffiliateAgreementFactory.create(
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False, study=study
         )
-        # Add the component agreement access group to the CDSA group.
+        # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
             parent_group=self.cdsa_group,
-            child_group=component_agreement.signed_agreement.anvil_access_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+
+    def test_data_affiliate_component_has_primary_not_in_group(self):
+        """Data affiliate component agreement, valid version, with primary with valid version, not in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=study)
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+
+    def test_data_affiliate_component_has_primary_with_invalid_version_in_group(self):
+        """Data affiliate component agreement, valid version, with primary with invalid version, in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__is_valid=False
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
 
-    def test_one_signed_agreement_data_affiliate_component_no_primary_no_access(self):
-        component_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__is_primary=False
+    def test_data_affiliate_has_primary_with_invalid_version_not_in_group(self):
+        """Data affiliate component agreement, valid version, with primary with invalid version, not in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__is_valid=False
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
         )
-        # Do not add the component agreement access group to the CDSA group.
+        # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
         #     parent_group=self.cdsa_group,
-        #     child_group=component_agreement.signed_agreement.anvil_access_group
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
+    def test_data_affiliate_component_no_primary_in_group(self):
+        """Data affiliate component agreement, with valid version, with no primary, in CDSA group."""
+        study = StudyFactory.create()
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 1)
+        record = cdsa_audit.errors[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_data_affiliate_component_no_primary_not_in_group(self):
+        """Data affiliate component agreement, with valid version, with no primary, not in CDSA group."""
+        study = StudyFactory.create()
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
-    def test_one_signed_agreement_data_affiliate_component_needs_access(self):
+    def test_data_affiliate_component_invalid_version_has_primary_in_group(self):
+        """Data affiliate component agreement, with invalid version, with a valid primary, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
-        component_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__is_primary=False, study=study
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
         )
-        # Do not add the component agreement access group to the CDSA group.
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_data_affiliate_component_invalid_version_has_primary_not_in_group(self):
+        """Data affiliate component agreement, with invalid version, with a valid primary, not in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=study)
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
         #     parent_group=self.cdsa_group,
-        #     child_group=component_agreement.signed_agreement.anvil_access_group
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_data_affiliate_component_invalid_version_has_primary_with_invalid_version_in_group(
+        self,
+    ):
+        """Data affiliate component agreement, with invalid version, with an invalid primary, in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=study)
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_data_affiliate_component_invalid_version_has_primary_with_invalid_version_not_in_group(
+        self,
+    ):
+        """Data affiliate component agreement, with invalid version, with an invalid primary, not in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=study)
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
-    def test_one_signed_agreement_data_affiliate_component_needs_error(self):
-        # No primary, but the agreement has access (incorrectly).
-        component_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__is_primary=False
+    def test_data_affiliate_component_invalid_version_no_primary_in_group(self):
+        """Data affiliate component agreement, with invalid version, with no primary, in CDSA group."""
+        study = StudyFactory.create()
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
         )
-        # Add the component agreement access group to the CDSA group (to trip the error).
+        # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
             parent_group=self.cdsa_group,
-            child_group=component_agreement.signed_agreement.anvil_access_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 1)
         record = cdsa_audit.errors[0]
         self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
-        self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_data_affiliate_component_invalid_version_no_primary_not_in_group(self):
+        """Data affiliate component agreement, with invalid version, with no primary, not in CDSA group."""
+        study = StudyFactory.create()
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
-    def test_one_signed_agreement_nondataaffiliate_component(self):
-        factories.NonDataAffiliateAgreementFactory.create(
+    def test_non_data_affiliate_primary_in_group(self):
+        """Non data affiliate primary agreement with valid version in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create()
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_non_data_affiliate_primary_not_in_group(self):
+        """Non data affiliate primary agreement with valid version not in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create()
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_non_data_affiliate_primary_invalid_version_in_group(self):
+        """Non data affiliate primary agreement with invalid version in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_non_data_affiliate_primary_invalid_version_not_in_group(self):
+        """Non data affiliate primary agreement, with invalid version, not in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False
+        )
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_non_data_affiliate_component_in_cdsa_group(self):
+        """Non data affiliate component agreement."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False
         )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        with self.assertRaises(RuntimeError):
-            cdsa_audit.run_audit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 1)
+        record = cdsa_audit.errors[0]
+        self.assertIsInstance(record, signed_agreement_audit.OtherError)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.ERROR_NON_DATA_AFFILIATE_COMPONENT)
 
-    def test_other_error(self):
-        signed_agreement = factories.SignedAgreementFactory.create(
-            is_primary=False, type="MEMBER"
+    def test_non_data_affiliate_component_not_in_cdsa_group(self):
+        """Non data affiliate component agreement."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False
         )
+        # Do not add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        cdsa_audit._audit_signed_agreement(signed_agreement)
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 1)
         record = cdsa_audit.errors[0]
         self.assertIsInstance(record, signed_agreement_audit.OtherError)
-        self.assertEqual(record.signed_agreement, signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.ERROR_OTHER_CASE)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.ERROR_NON_DATA_AFFILIATE_COMPONENT)
 
 
 class SignedAgreementAccessAuditTableTest(TestCase):
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 96df2265..60845199 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -3898,14 +3898,14 @@ def test_context_verified_table_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_CDSA,
+            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
     def test_context_verified_table_no_access(self):
         """verified_table shows a record when audit has verified no access."""
         member_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__is_primary=False
+            signed_agreement__version__major_version__is_valid=False
         )
         # Check the table in the context.
         self.client.force_login(self.user)
@@ -3923,7 +3923,7 @@ def test_context_verified_table_no_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.NO_PRIMARY_CDSA,
+            signed_agreement_audit.SignedAgreementAccessAudit.INVALID_AGREEMENT_VERSION,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
@@ -3946,7 +3946,7 @@ def test_context_needs_action_table_grant(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_CDSA,
+            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 
@@ -3974,7 +3974,7 @@ def test_context_error_table_has_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.NO_PRIMARY_CDSA,
+            signed_agreement_audit.SignedAgreementAccessAudit.NO_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index d64fcc12..22a74823 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -401,9 +401,9 @@ class SignedAgreementAudit(AnVILConsortiumManagerViewRequired, TemplateView):
     )
 
     def get(self, request, *args, **kwargs):
-        try:
-            self.audit = signed_agreement_audit.SignedAgreementAccessAudit()
-        except models.ManagedGroup.DoesNotExist:
+        if not models.ManagedGroup.objects.filter(
+            name=settings.ANVIL_CDSA_GROUP_NAME
+        ).exists():
             messages.error(
                 self.request,
                 self.ERROR_CDSA_GROUP_DOES_NOT_EXIST.format(
@@ -415,12 +415,12 @@ def get(self, request, *args, **kwargs):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        # Run the audit on all SignedAgreements.
-        self.audit.run_audit()
-        context["verified_table"] = self.audit.get_verified_table()
-        context["errors_table"] = self.audit.get_errors_table()
-        context["needs_action_table"] = self.audit.get_needs_action_table()
-        context["audit"] = self.audit
+        audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        audit.run_audit()
+        context["verified_table"] = audit.get_verified_table()
+        context["errors_table"] = audit.get_errors_table()
+        context["needs_action_table"] = audit.get_needs_action_table()
+        context["audit"] = audit
         return context
 
 

From 20257e5f0759972b48b28b7b601a201d277eb8fb Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 10:00:20 -0700
Subject: [PATCH 32/53] Update CDSA workspace audit to handle invalid major
 versions

Similar to the SignedAgreement audit. Expand tests.
---
 primed/cdsa/audit/workspace_audit.py |  93 ++++++----
 primed/cdsa/tests/test_audit.py      | 264 +++++++++++++++++++++++----
 primed/cdsa/tests/test_views.py      |   8 +-
 3 files changed, 295 insertions(+), 70 deletions(-)

diff --git a/primed/cdsa/audit/workspace_audit.py b/primed/cdsa/audit/workspace_audit.py
index 2d41d60b..e5a8f667 100644
--- a/primed/cdsa/audit/workspace_audit.py
+++ b/primed/cdsa/audit/workspace_audit.py
@@ -128,10 +128,11 @@ class WorkspaceAccessAudit:
     """Audit for CDSA Workspaces."""
 
     # Access verified.
-    VALID_PRIMARY_CDSA = "Valid primary CDSA."
+    VALID_PRIMARY_AGREEMENT = "Valid primary CDSA."
 
     # Allowed reasons for no access.
-    NO_PRIMARY_CDSA = "No primary CDSA for this study exists."
+    NO_PRIMARY_AGREEMENT = "No primary CDSA for this study exists."
+    INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
 
     # Other errors
     ERROR_OTHER_CASE = "Workspace did not match any expected situations."
@@ -149,7 +150,6 @@ def __init__(self):
         self.needs_action = []
         self.errors = []
 
-    # Audit a single signed agreement.
     def _audit_workspace(self, workspace):
         # Check if the access group is in the overall CDSA group.
         auth_domain = workspace.workspace.authorization_domains.first()
@@ -157,47 +157,76 @@ def _audit_workspace(self, workspace):
             parent_group=auth_domain,
             child_group=self.anvil_cdsa_group,
         ).exists()
-        # WRITE ME!
-        # See if there is a primary data affiliate agreement for this study.
-        try:
-            primary_agreement = models.DataAffiliateAgreement.objects.get(
-                study=workspace.study,
-                signed_agreement__is_primary=True,
+        primary_qs = models.DataAffiliateAgreement.objects.filter(
+            study=workspace.study, signed_agreement__is_primary=True
+        )
+        primary_exists = primary_qs.exists()
+
+        if primary_exists:
+            primary_agreement = (
+                primary_qs.filter(
+                    signed_agreement__version__major_version__is_valid=True
+                )
+                .order_by(
+                    "-signed_agreement__version__major_version__version",
+                    "-signed_agreement__version__minor_version",
+                )
+                .first()
             )
-            if has_cdsa_group_in_auth_domain:
-                self.verified.append(
-                    VerifiedAccess(
-                        workspace=workspace,
-                        data_affiliate_agreement=primary_agreement,
-                        note=self.VALID_PRIMARY_CDSA,
+            if primary_agreement:
+                if has_cdsa_group_in_auth_domain:
+                    self.verified.append(
+                        VerifiedAccess(
+                            workspace=workspace,
+                            data_affiliate_agreement=primary_agreement,
+                            note=self.VALID_PRIMARY_AGREEMENT,
+                        )
                     )
-                )
-                return
+                    return
+                else:
+                    self.needs_action.append(
+                        GrantAccess(
+                            workspace=workspace,
+                            data_affiliate_agreement=primary_agreement,
+                            note=self.VALID_PRIMARY_AGREEMENT,
+                        )
+                    )
+                    return
             else:
-                self.needs_action.append(
-                    GrantAccess(
-                        workspace=workspace,
-                        data_affiliate_agreement=primary_agreement,
-                        note=self.VALID_PRIMARY_CDSA,
+                if has_cdsa_group_in_auth_domain:
+                    self.needs_action.append(
+                        RemoveAccess(
+                            workspace=workspace,
+                            data_affiliate_agreement=primary_agreement,
+                            note=self.INVALID_AGREEMENT_VERSION,
+                        )
                     )
-                )
-                return
-        except models.DataAffiliateAgreement.DoesNotExist:
-            if not has_cdsa_group_in_auth_domain:
-                self.verified.append(
-                    VerifiedNoAccess(
+                    return
+                else:
+                    self.verified.append(
+                        VerifiedNoAccess(
+                            workspace=workspace,
+                            data_affiliate_agreement=primary_agreement,
+                            note=self.INVALID_AGREEMENT_VERSION,
+                        )
+                    )
+                    return
+        else:
+            if has_cdsa_group_in_auth_domain:
+                self.errors.append(
+                    RemoveAccess(
                         workspace=workspace,
                         data_affiliate_agreement=None,
-                        note=self.NO_PRIMARY_CDSA,
+                        note=self.NO_PRIMARY_AGREEMENT,
                     )
                 )
                 return
             else:
-                self.errors.append(
-                    RemoveAccess(
+                self.verified.append(
+                    VerifiedNoAccess(
                         workspace=workspace,
                         data_affiliate_agreement=None,
-                        note=self.NO_PRIMARY_CDSA,
+                        note=self.NO_PRIMARY_AGREEMENT,
                     )
                 )
                 return
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 1edad70a..c0e2e700 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -1379,16 +1379,7 @@ def test_completed(self):
         cdsa_audit.run_audit()
         self.assertTrue(cdsa_audit.completed)
 
-    def test_no_workspaces(self):
-        """Audit works when there are no workspaces."""
-        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        self.assertFalse(cdsa_audit.completed)
-        cdsa_audit.run_audit()
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
-        self.assertEqual(len(cdsa_audit.errors), 0)
-
-    def test_one_workspace_with_primary_verified_access(self):
+    def test_primary_in_auth_domain(self):
         study = StudyFactory.create()
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -1400,17 +1391,39 @@ def test_one_workspace_with_primary_verified_access(self):
             child_group=self.cdsa_group,
         )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_workspace(workspace)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_primary_not_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study
+        )
+        # Do not add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.GrantAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
 
-    def test_one_workspace_no_primary_no_verified_access(self):
+    def test_no_primary_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
         # Do not CDSA group to the auth domain.
         # GroupGroupMembershipFactory.create(
@@ -1418,25 +1431,113 @@ def test_one_workspace_no_primary_no_verified_access(self):
         #     child_group=self.cdsa_group,
         # )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_workspace(workspace)
         self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_no_primary_in_auth_domain(self):
+        workspace = factories.CDSAWorkspaceFactory.create()
+        # Add the CDSA group to the auth domain - this is an error.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 1)
+        record = cdsa_audit.errors[0]
+        self.assertIsInstance(record, workspace_audit.RemoveAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+
+    def test_primary_invalid_version_not_in_auth_domain(self):
+        workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False,
+            study=workspace.study,
+        )
+        # Do not add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
-    def test_one_workspace_no_primary_error_has_access(self):
+    def test_primary_invalid_version_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
-        # Add the CDSA group to the auth domain - this is an error.
+        factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__version__major_version__is_valid=False,
+            study=workspace.study,
+        )
+        # Add the CDSA group to the auth domain.
         GroupGroupMembershipFactory.create(
             parent_group=workspace.workspace.authorization_domains.first(),
             child_group=self.cdsa_group,
         )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.RemoveAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+
+    def test_component_agreement_not_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__is_primary=False
+        )
+        # Do not add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+
+    def test_component_agreement_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__is_primary=False
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 1)
@@ -1444,13 +1545,71 @@ def test_one_workspace_no_primary_error_has_access(self):
         self.assertIsInstance(record, workspace_audit.RemoveAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
-    def test_one_workspace_with_primary_no_access(self):
+    def test_two_valid_primary_agreements_in_auth_domain(self):
         study = StudyFactory.create()
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__version=1
+        )
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
-            study=study
+            study=study, signed_agreement__version__major_version__version=2
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_two_valid_primary_agreements_same_major_version_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        major_version = factories.AgreementMajorVersionFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__version__major_version=major_version,
+            signed_agreement__version__minor_version=1,
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__version__major_version=major_version,
+            signed_agreement__version__minor_version=2,
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_two_valid_primary_agreements_not_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__version=1
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__version=2
         )
         # Do not add the CDSA group to the auth domain.
         # GroupGroupMembershipFactory.create(
@@ -1458,21 +1617,49 @@ def test_one_workspace_with_primary_no_access(self):
         #     child_group=self.cdsa_group,
         # )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        cdsa_audit.run_audit()
+        cdsa_audit._audit_workspace(workspace)
         self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, workspace_audit.GrantAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_two_primary_one_valid_one_invalid_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__is_valid=False
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__is_valid=True
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
 
-    def test_ignores_component_agreement(self):
+    def test_two_primary_one_valid_one_invalid_not_in_auth_domain(self):
         study = StudyFactory.create()
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__is_primary=False
+            study=study, signed_agreement__version__major_version__is_valid=False
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study, signed_agreement__version__major_version__is_valid=True
         )
         # Do not add the CDSA group to the auth domain.
         # GroupGroupMembershipFactory.create(
@@ -1480,13 +1667,22 @@ def test_ignores_component_agreement(self):
         #     child_group=self.cdsa_group,
         # )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
-        cdsa_audit.run_audit()
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
-        self.assertIsNone(record.data_affiliate_agreement)
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.GrantAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_no_workspaces(self):
+        """Audit works when there are no workspaces."""
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        self.assertFalse(cdsa_audit.completed)
+        cdsa_audit.run_audit()
+        self.assertEqual(len(cdsa_audit.verified), 0)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
 
@@ -1513,12 +1709,12 @@ def test_two_workspaces(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace_1)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
         record = cdsa_audit.verified[1]
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace_2)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
 
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 60845199..953a9c37 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -4082,7 +4082,7 @@ def test_context_verified_table_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_CDSA,
+            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
@@ -4106,7 +4106,7 @@ def test_context_verified_table_no_access(self):
         self.assertIsNone(table.rows[0].get_cell_value("data_affiliate_agreement"))
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.NO_PRIMARY_CDSA,
+            workspace_audit.WorkspaceAccessAudit.NO_PRIMARY_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
@@ -4135,7 +4135,7 @@ def test_context_needs_action_table_grant(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_CDSA,
+            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 
@@ -4159,7 +4159,7 @@ def test_context_error_table_has_access(self):
         self.assertIsNone(table.rows[0].get_cell_value("data_affiliate_agreement"))
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.NO_PRIMARY_CDSA,
+            workspace_audit.WorkspaceAccessAudit.NO_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 

From a13beb6f74fee3ad19d834f16a8eec46ce2f517b Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 11:08:37 -0700
Subject: [PATCH 33/53] Add a status field to the SignedAgreement model

This field will indicate if a signed agreement is active or replaced
(or other statuses as added in the future).
---
 .../0009_signedagreement_add_field_status.py  | 45 +++++++++++++++++++
 primed/cdsa/models.py                         | 20 ++++++++-
 primed/cdsa/tests/test_models.py              | 16 +++++++
 3 files changed, 79 insertions(+), 2 deletions(-)
 create mode 100644 primed/cdsa/migrations/0009_signedagreement_add_field_status.py

diff --git a/primed/cdsa/migrations/0009_signedagreement_add_field_status.py b/primed/cdsa/migrations/0009_signedagreement_add_field_status.py
new file mode 100644
index 00000000..aa0a845c
--- /dev/null
+++ b/primed/cdsa/migrations/0009_signedagreement_add_field_status.py
@@ -0,0 +1,45 @@
+# Generated by Django 3.2.19 on 2023-09-19 17:33
+
+from django.db import migrations, models
+import django.utils.timezone
+import model_utils.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('cdsa', '0008_agreementmajorversion_add_is_valid'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='historicalsignedagreement',
+            name='status',
+            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='active', max_length=100, no_check_for_status=True, verbose_name='status'),
+        ),
+        migrations.AddField(
+            model_name='historicalsignedagreement',
+            name='status_changed',
+            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
+        ),
+        migrations.AddField(
+            model_name='signedagreement',
+            name='status',
+            field=model_utils.fields.StatusField(choices=[(0, 'dummy')], default='active', max_length=100, no_check_for_status=True, verbose_name='status'),
+        ),
+        migrations.AddField(
+            model_name='signedagreement',
+            name='status_changed',
+            field=model_utils.fields.MonitorField(default=django.utils.timezone.now, monitor='status', verbose_name='status changed'),
+        ),
+        migrations.AlterField(
+            model_name='agreementmajorversion',
+            name='is_valid',
+            field=models.BooleanField(default=True, help_text='Boolean indicator of whether this version is valid.'),
+        ),
+        migrations.AlterField(
+            model_name='historicalagreementmajorversion',
+            name='is_valid',
+            field=models.BooleanField(default=True, help_text='Boolean indicator of whether this version is valid.'),
+        ),
+    ]
diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index ac972da7..8a694070 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -13,6 +13,7 @@
 from django.db import models
 from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
+from model_utils.models import StatusModel
 from simple_history.models import HistoricalRecords
 
 from primed.duo.models import DataUseOntologyModel
@@ -94,7 +95,22 @@ def is_valid(self):
         return True
 
 
-class SignedAgreement(TimeStampedModel, models.Model):
+class SignedAgreementStatusMixin:
+    """Mixin to define status choices for SignedAgreements."""
+
+    # This is required because we are using django-model-util's StatusModel with django-simple-history:
+    # See GitHub issue: https://github.com/jazzband/django-simple-history/issues/190
+
+    class StatusChoices(models.TextChoices):
+        ACTIVE = "active", "Active"
+        REPLACED = "replaced", "Replaced"
+
+    STATUS = StatusChoices.choices
+
+
+class SignedAgreement(
+    TimeStampedModel, SignedAgreementStatusMixin, StatusModel, models.Model
+):
     """Model to track verified, signed consortium data sharing agreements."""
 
     MEMBER = "member"
@@ -151,7 +167,7 @@ class SignedAgreement(TimeStampedModel, models.Model):
         on_delete=models.PROTECT,
     )
 
-    history = HistoricalRecords()
+    history = HistoricalRecords(bases=[SignedAgreementStatusMixin, models.Model])
 
     def __str__(self):
         return "{}".format(self.cc_id)
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 61e62812..7db9f63d 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -288,6 +288,22 @@ def test_agreement_version_protect(self):
         with self.assertRaises(ProtectedError):
             agreement_version.delete()
 
+    def test_status_field(self):
+        # default
+        instance = factories.SignedAgreementFactory.create()
+        self.assertEqual(instance.status, instance.StatusChoices.ACTIVE)
+        instance.full_clean()
+        # other choices
+        instance = factories.SignedAgreementFactory.create(
+            status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        self.assertEqual(instance.status, instance.StatusChoices.REPLACED)
+        instance.full_clean()
+        # not allowed
+        instance = factories.SignedAgreementFactory.create(status="foo")
+        with self.assertRaises(ValidationError):
+            instance.full_clean()
+
     def test_get_combined_type(self):
         obj = factories.MemberAgreementFactory()
         self.assertEqual(obj.signed_agreement.combined_type, "Member")

From dac962a71a5b76a0f9acd32c0881c016c59db367 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 11:59:14 -0700
Subject: [PATCH 34/53] Add status to SignedAgreement tables

---
 primed/cdsa/tables.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/primed/cdsa/tables.py b/primed/cdsa/tables.py
index ae3c6b40..b2a2008f 100644
--- a/primed/cdsa/tables.py
+++ b/primed/cdsa/tables.py
@@ -67,6 +67,7 @@ class Meta:
             "agreement_group",
             "agreement_type",
             "version",
+            "status",
             "date_signed",
             "number_accessors",
         )
@@ -99,6 +100,7 @@ class Meta:
             "signed_agreement__representative_role",
             "signed_agreement__signing_institution",
             "signed_agreement__version",
+            "signed_agreement__status",
             "signed_agreement__date_signed",
             "number_accessors",
         )
@@ -131,6 +133,7 @@ class Meta:
             "signed_agreement__representative_role",
             "signed_agreement__signing_institution",
             "signed_agreement__version",
+            "signed_agreement__status",
             "signed_agreement__date_signed",
             "number_accessors",
         )
@@ -140,7 +143,6 @@ class NonDataAffiliateAgreementTable(tables.Table):
     """Table to display `DataAffiliateAgreement` objects."""
 
     signed_agreement__cc_id = tables.Column(linkify=True)
-    signed_agreement__is_primary = BooleanIconColumn()
     signed_agreement__representative__name = tables.Column(
         linkify=lambda record: record.signed_agreement.representative.get_absolute_url(),
         verbose_name="Representative",
@@ -161,6 +163,7 @@ class Meta:
             "signed_agreement__representative_role",
             "signed_agreement__signing_institution",
             "signed_agreement__version",
+            "signed_agreement__status",
             "signed_agreement__date_signed",
             "number_accessors",
         )

From b78d6aacea40574d98f44209e146922b8e96642d Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 12:10:32 -0700
Subject: [PATCH 35/53] Add status field to admin displays

---
 primed/cdsa/admin.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/primed/cdsa/admin.py b/primed/cdsa/admin.py
index ff09f8ef..cdc71f4d 100644
--- a/primed/cdsa/admin.py
+++ b/primed/cdsa/admin.py
@@ -54,6 +54,7 @@ class SignedAgreement(SimpleHistoryAdmin):
         "type",
         "is_primary",
         "version",
+        "status",
     )
     search_fields = (
         "representative",
@@ -79,6 +80,7 @@ class MemberAgreementAdmin(SimpleHistoryAdmin):
     list_filter = (
         "study_site",
         "signed_agreement__is_primary",
+        "signed_agreement__status",
     )
 
 
@@ -93,6 +95,7 @@ class DataAffiliateAgreementAdmin(SimpleHistoryAdmin):
     list_filter = (
         "study",
         "signed_agreement__is_primary",
+        "signed_agreement__status",
     )
 
 
@@ -104,7 +107,10 @@ class NonDataAffiliateAgreementAdmin(SimpleHistoryAdmin):
         "signed_agreement",
         "affiliation",
     )
-    list_filter = ("signed_agreement__is_primary",)
+    list_filter = (
+        "signed_agreement__is_primary",
+        "signed_agreement__status",
+    )
 
 
 @admin.register(models.CDSAWorkspace)

From fd21357eec862acf187876182670dbd858314d86 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 12:15:44 -0700
Subject: [PATCH 36/53] Show SignedAgreement status on detail pages

---
 primed/templates/cdsa/dataaffiliateagreement_detail.html    | 1 +
 primed/templates/cdsa/memberagreement_detail.html           | 1 +
 primed/templates/cdsa/nondataaffiliateagreement_detail.html | 1 +
 3 files changed, 3 insertions(+)

diff --git a/primed/templates/cdsa/dataaffiliateagreement_detail.html b/primed/templates/cdsa/dataaffiliateagreement_detail.html
index e83ed685..078c82d0 100644
--- a/primed/templates/cdsa/dataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/dataaffiliateagreement_detail.html
@@ -24,6 +24,7 @@
   <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
     <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
   </dd>
+  <dt class="col-sm-2">Status</dt> <dd class="col-sm-9">{{ object.signed_agreement.get_status_display }}</dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Study</dt> <dd class="col-sm-9">
diff --git a/primed/templates/cdsa/memberagreement_detail.html b/primed/templates/cdsa/memberagreement_detail.html
index a74f006e..eafdde26 100644
--- a/primed/templates/cdsa/memberagreement_detail.html
+++ b/primed/templates/cdsa/memberagreement_detail.html
@@ -24,6 +24,7 @@
   <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
     <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
   </dd>
+  <dt class="col-sm-2">Status</dt> <dd class="col-sm-9">{{ object.signed_agreement.get_status_display }}</dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Study site</dt> <dd class="col-sm-9">
diff --git a/primed/templates/cdsa/nondataaffiliateagreement_detail.html b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
index 3eea2fee..e0c5df9c 100644
--- a/primed/templates/cdsa/nondataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
@@ -24,6 +24,7 @@
   <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
     <a href="{{ object.signed_agreement.version.get_absolute_url }}">{{ object.signed_agreement.version }}</a>
   </dd>
+  <dt class="col-sm-2">Status</dt> <dd class="col-sm-9">{{ object.signed_agreement.get_status_display }}</dd>
   <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.signed_agreement.date_signed }}</dd>
 
   <dt class="col-sm-2">Affiliation</dt> <dd class="col-sm-9">{{ object.affiliation }}</dd>

From a1fc49f8647e0ef00e005872200336b322a6cbe0 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 12:18:49 -0700
Subject: [PATCH 37/53] Test that status was set correctly in Create views

---
 primed/cdsa/tests/test_views.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 953a9c37..88b8bb8f 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -659,6 +659,9 @@ def test_can_create_object(self):
         self.assertEqual(
             new_agreement.anvil_access_group.name, "TEST_PRIMED_CDSA_ACCESS_1234"
         )
+        self.assertEqual(
+            new_agreement.status, models.SignedAgreement.StatusChoices.ACTIVE
+        )
         # Check the agreement type.
         self.assertEqual(models.MemberAgreement.objects.count(), 1)
         new_agreement_type = models.MemberAgreement.objects.latest("pk")
@@ -1689,6 +1692,9 @@ def test_can_create_object(self):
         self.assertEqual(
             new_agreement.anvil_access_group.name, "TEST_PRIMED_CDSA_ACCESS_1234"
         )
+        self.assertEqual(
+            new_agreement.status, models.SignedAgreement.StatusChoices.ACTIVE
+        )
         # Check the agreement type.
         self.assertEqual(models.DataAffiliateAgreement.objects.count(), 1)
         new_agreement_type = models.DataAffiliateAgreement.objects.latest("pk")
@@ -2856,6 +2862,9 @@ def test_can_create_object(self):
         self.assertEqual(
             new_agreement.anvil_access_group.name, "TEST_PRIMED_CDSA_ACCESS_1234"
         )
+        self.assertEqual(
+            new_agreement.status, models.SignedAgreement.StatusChoices.ACTIVE
+        )
         # Check the agreement type.
         self.assertEqual(models.NonDataAffiliateAgreement.objects.count(), 1)
         new_agreement_type = models.NonDataAffiliateAgreement.objects.latest("pk")

From b541626963e5839f6d04589945bd8b601f826c89 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 12:23:29 -0700
Subject: [PATCH 38/53] Remove commented out tests that were previously
 replaced

---
 primed/cdsa/tests/test_audit.py | 218 --------------------------------
 1 file changed, 218 deletions(-)

diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index c0e2e700..2e51f5ce 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -125,224 +125,6 @@ def test_loops_over_signed_agreements(self):
         cdsa_audit.run_audit()
         self.assertEqual(len(cdsa_audit.needs_action), 2)
 
-    # def test_one_signed_agreement_primary_verified_access(self):
-    #     signed_agreement = factories.SignedAgreementFactory.create()
-    #     # Add the signed agreement access group to the CDSA group.
-    #     GroupGroupMembershipFactory.create(
-    #         parent_group=self.cdsa_group,
-    #         child_group=signed_agreement.anvil_access_group,
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit.run_audit()
-    #     self.assertEqual(len(cdsa_audit.verified), 1)
-    #     record = cdsa_audit.verified[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-    #     self.assertEqual(record.signed_agreement, signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_primary_needs_access(self):
-    #     signed_agreement = factories.SignedAgreementFactory.create()
-    #     # Do not add the signed agreement access group to the CDSA group.
-    #     # GroupGroupMembershipFactory.create(
-    #     #     parent_group=self.cdsa_group, child_group=signed_agreement.anvil_access_group
-    #     # )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit.run_audit()
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
-    #     record = cdsa_audit.needs_action[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-    #     self.assertEqual(record.signed_agreement, signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_CDSA)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_member_component_verified_access(self):
-    #     study_site = StudySiteFactory.create()
-    #     factories.MemberAgreementFactory.create(study_site=study_site)
-    #     component_agreement = factories.MemberAgreementFactory.create(
-    #         signed_agreement__is_primary=False, study_site=study_site
-    #     )
-    #     # Add the component agreement access group to the CDSA group.
-    #     GroupGroupMembershipFactory.create(
-    #         parent_group=self.cdsa_group,
-    #         child_group=component_agreement.signed_agreement.anvil_access_group,
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 1)
-    #     record = cdsa_audit.verified[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_member_component_no_primary_no_access(self):
-    #     component_agreement = factories.MemberAgreementFactory.create(
-    #         signed_agreement__is_primary=False
-    #     )
-    #     # Do not add the component agreement access group to the CDSA group.
-    #     # GroupGroupMembershipFactory.create(
-    #     #     parent_group=self.cdsa_group,
-    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
-    #     # )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 1)
-    #     record = cdsa_audit.verified[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_member_component_needs_access(self):
-    #     study_site = StudySiteFactory.create()
-    #     factories.MemberAgreementFactory.create(study_site=study_site)
-    #     component_agreement = factories.MemberAgreementFactory.create(
-    #         signed_agreement__is_primary=False, study_site=study_site
-    #     )
-    #     # Do not add the component agreement access group to the CDSA group.
-    #     # GroupGroupMembershipFactory.create(
-    #     #     parent_group=self.cdsa_group,
-    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
-    #     # )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
-    #     record = cdsa_audit.needs_action[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_member_component_error(self):
-    #     # No primary, but the agreement has access (incorrectly).
-    #     component_agreement = factories.MemberAgreementFactory.create(
-    #         signed_agreement__is_primary=False
-    #     )
-    #     # Add the component agreement access group to the CDSA group (to trip the error).
-    #     GroupGroupMembershipFactory.create(
-    #         parent_group=self.cdsa_group,
-    #         child_group=component_agreement.signed_agreement.anvil_access_group,
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 1)
-    #     record = cdsa_audit.errors[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
-
-    # def test_one_signed_agreement_data_affiliate_component_verified_access(self):
-    #     study = StudyFactory.create()
-    #     factories.DataAffiliateAgreementFactory.create(study=study)
-    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
-    #         signed_agreement__is_primary=False, study=study
-    #     )
-    #     # Add the component agreement access group to the CDSA group.
-    #     GroupGroupMembershipFactory.create(
-    #         parent_group=self.cdsa_group,
-    #         child_group=component_agreement.signed_agreement.anvil_access_group,
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 1)
-    #     record = cdsa_audit.verified[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_data_affiliate_component_no_primary_no_access(self):
-    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
-    #         signed_agreement__is_primary=False
-    #     )
-    #     # Do not add the component agreement access group to the CDSA group.
-    #     # GroupGroupMembershipFactory.create(
-    #     #     parent_group=self.cdsa_group,
-    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
-    #     # )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 1)
-    #     record = cdsa_audit.verified[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_data_affiliate_component_needs_access(self):
-    #     study = StudyFactory.create()
-    #     factories.DataAffiliateAgreementFactory.create(study=study)
-    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
-    #         signed_agreement__is_primary=False, study=study
-    #     )
-    #     # Do not add the component agreement access group to the CDSA group.
-    #     # GroupGroupMembershipFactory.create(
-    #     #     parent_group=self.cdsa_group,
-    #     #     child_group=component_agreement.signed_agreement.anvil_access_group
-    #     # )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 1)
-    #     record = cdsa_audit.needs_action[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_CDSA)
-    #     self.assertEqual(len(cdsa_audit.errors), 0)
-
-    # def test_one_signed_agreement_data_affiliate_component_needs_error(self):
-    #     # No primary, but the agreement has access (incorrectly).
-    #     component_agreement = factories.DataAffiliateAgreementFactory.create(
-    #         signed_agreement__is_primary=False
-    #     )
-    #     # Add the component agreement access group to the CDSA group (to trip the error).
-    #     GroupGroupMembershipFactory.create(
-    #         parent_group=self.cdsa_group,
-    #         child_group=component_agreement.signed_agreement.anvil_access_group,
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(component_agreement.signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 1)
-    #     record = cdsa_audit.errors[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
-    #     self.assertEqual(record.signed_agreement, component_agreement.signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_CDSA)
-
-    # def test_one_signed_agreement_nondataaffiliate_component(self):
-    #     factories.NonDataAffiliateAgreementFactory.create(
-    #         signed_agreement__is_primary=False
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     with self.assertRaises(RuntimeError):
-    #         cdsa_audit.run_audit()
-
-    # def test_other_error(self):
-    #     signed_agreement = factories.SignedAgreementFactory.create(
-    #         is_primary=False, type="MEMBER"
-    #     )
-    #     cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
-    #     cdsa_audit._audit_signed_agreement(signed_agreement)
-    #     self.assertEqual(len(cdsa_audit.verified), 0)
-    #     self.assertEqual(len(cdsa_audit.needs_action), 0)
-    #     self.assertEqual(len(cdsa_audit.errors), 1)
-    #     record = cdsa_audit.errors[0]
-    #     self.assertIsInstance(record, signed_agreement_audit.OtherError)
-    #     self.assertEqual(record.signed_agreement, signed_agreement)
-    #     self.assertEqual(record.note, cdsa_audit.ERROR_OTHER_CASE)
-
-    # New tests
     def test_member_primary_in_group(self):
         """Member primary agreement with valid version in CDSA group."""
         this_agreement = factories.MemberAgreementFactory.create()

From 0021dfdf18fafc4e3852afe5c9578ba8f634df1a Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 13:38:39 -0700
Subject: [PATCH 39/53] Update SignedAgreementAudit to check status field

In addition to checking whether the agreement version is valid,
the SignedAgreementAudit now checks whether the agreement is active.
---
 primed/cdsa/audit/signed_agreement_audit.py | 185 +++++++++++---
 primed/cdsa/tests/test_audit.py             | 269 ++++++++++++++++++++
 2 files changed, 417 insertions(+), 37 deletions(-)

diff --git a/primed/cdsa/audit/signed_agreement_audit.py b/primed/cdsa/audit/signed_agreement_audit.py
index 9a9ab47d..26f0b909 100644
--- a/primed/cdsa/audit/signed_agreement_audit.py
+++ b/primed/cdsa/audit/signed_agreement_audit.py
@@ -126,13 +126,16 @@ class SignedAgreementAccessAudit:
     """Audit for Signed Agreements."""
 
     # Access verified.
-    VALID_PRIMARY_AGREEMENT = "Valid primary CDSA."
-    VALID_COMPONENT_AGREEMENT = "Valid component CDSA."
+    VALID_PRIMARY_AGREEMENT = "Valid, active primary CDSA."
+    VALID_COMPONENT_AGREEMENT = "Valid, active component CDSA."
 
     # Allowed reasons for no access.
-    NO_PRIMARY_AGREEMENT = "No valid primary CDSA for this group exists."
-    PRIMARY_NOT_VALID = "Primary agreement for this CDSA is not valid."
+    NO_PRIMARY_AGREEMENT = "No primary CDSA for this group exists."
+    PRIMARY_NOT_VALID = (
+        "Primary agreement for this CDSA is either not valid or not active."
+    )
     INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
+    INACTIVE_AGREEMENT = "CDSA is inactive."
 
     # Other errors
     ERROR_NON_DATA_AFFILIATE_COMPONENT = (
@@ -159,24 +162,46 @@ def _audit_primary_agreement(self, signed_agreement):
         """
         is_valid = signed_agreement.version.major_version.is_valid
         in_cdsa_group = signed_agreement.is_in_cdsa_group()
+        is_active = (
+            signed_agreement.status == models.SignedAgreement.StatusChoices.ACTIVE
+        )
 
         if is_valid:
-            if in_cdsa_group:
-                self.verified.append(
-                    VerifiedAccess(
-                        signed_agreement=signed_agreement,
-                        note=self.VALID_PRIMARY_AGREEMENT,
+            if is_active:
+                if in_cdsa_group:
+                    self.verified.append(
+                        VerifiedAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.VALID_PRIMARY_AGREEMENT,
+                        )
                     )
-                )
-                return
+                    return
+                else:
+                    self.needs_action.append(
+                        GrantAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.VALID_PRIMARY_AGREEMENT,
+                        )
+                    )
+                    return
+
             else:
-                self.needs_action.append(
-                    GrantAccess(
-                        signed_agreement=signed_agreement,
-                        note=self.VALID_PRIMARY_AGREEMENT,
+                if in_cdsa_group:
+                    self.needs_action.append(
+                        RemoveAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.INACTIVE_AGREEMENT,
+                        )
                     )
-                )
-                return
+                    return
+                else:
+                    self.verified.append(
+                        VerifiedNoAccess(
+                            signed_agreement=signed_agreement,
+                            note=self.INACTIVE_AGREEMENT,
+                        )
+                    )
+                    return
         else:
             if in_cdsa_group:
                 self.needs_action.append(
@@ -214,6 +239,9 @@ def _audit_component_agreement(self, signed_agreement):
         """
         is_valid = signed_agreement.version.major_version.is_valid
         in_cdsa_group = signed_agreement.is_in_cdsa_group()
+        is_active = (
+            signed_agreement.status == models.SignedAgreement.StatusChoices.ACTIVE
+        )
 
         # Get the set of potential primary agreements for this component.
         if hasattr(signed_agreement, "memberagreement"):
@@ -238,34 +266,53 @@ def _audit_component_agreement(self, signed_agreement):
             return
         primary_exists = primary_qs.exists()
         primary_valid = primary_qs.filter(
-            version__major_version__is_valid=True
+            version__major_version__is_valid=True,
+            status=models.SignedAgreement.StatusChoices.ACTIVE,
         ).exists()
 
         if primary_exists:
-            if is_valid:
-                if primary_valid:
-                    if in_cdsa_group:
-                        self.verified.append(
-                            VerifiedAccess(
-                                signed_agreement=signed_agreement,
-                                note=self.VALID_COMPONENT_AGREEMENT,
+            if primary_valid:
+                if is_valid:
+                    if is_active:
+                        if in_cdsa_group:
+                            self.verified.append(
+                                VerifiedAccess(
+                                    signed_agreement=signed_agreement,
+                                    note=self.VALID_COMPONENT_AGREEMENT,
+                                )
                             )
-                        )
-                        return
+                            return
+                        else:
+                            self.needs_action.append(
+                                GrantAccess(
+                                    signed_agreement=signed_agreement,
+                                    note=self.VALID_COMPONENT_AGREEMENT,
+                                )
+                            )
+                            return
                     else:
-                        self.needs_action.append(
-                            GrantAccess(
-                                signed_agreement=signed_agreement,
-                                note=self.VALID_COMPONENT_AGREEMENT,
+                        if in_cdsa_group:
+                            self.needs_action.append(
+                                RemoveAccess(
+                                    signed_agreement=signed_agreement,
+                                    note=self.INACTIVE_AGREEMENT,
+                                )
                             )
-                        )
-                        return
+                            return
+                        else:
+                            self.verified.append(
+                                VerifiedNoAccess(
+                                    signed_agreement=signed_agreement,
+                                    note=self.INACTIVE_AGREEMENT,
+                                )
+                            )
+                            return
                 else:
                     if in_cdsa_group:
                         self.needs_action.append(
                             RemoveAccess(
                                 signed_agreement=signed_agreement,
-                                note=self.PRIMARY_NOT_VALID,
+                                note=self.INVALID_AGREEMENT_VERSION,
                             )
                         )
                         return
@@ -273,7 +320,7 @@ def _audit_component_agreement(self, signed_agreement):
                         self.verified.append(
                             VerifiedNoAccess(
                                 signed_agreement=signed_agreement,
-                                note=self.PRIMARY_NOT_VALID,
+                                note=self.INVALID_AGREEMENT_VERSION,
                             )
                         )
                         return
@@ -282,7 +329,7 @@ def _audit_component_agreement(self, signed_agreement):
                     self.needs_action.append(
                         RemoveAccess(
                             signed_agreement=signed_agreement,
-                            note=self.INVALID_AGREEMENT_VERSION,
+                            note=self.PRIMARY_NOT_VALID,
                         )
                     )
                     return
@@ -290,7 +337,7 @@ def _audit_component_agreement(self, signed_agreement):
                     self.verified.append(
                         VerifiedNoAccess(
                             signed_agreement=signed_agreement,
-                            note=self.INVALID_AGREEMENT_VERSION,
+                            note=self.PRIMARY_NOT_VALID,
                         )
                     )
                     return
@@ -312,6 +359,70 @@ def _audit_component_agreement(self, signed_agreement):
                 )
                 return
 
+        # if primary_exists:
+        #     if is_valid:
+        #         if primary_valid:
+        #             if in_cdsa_group:
+        #             else:
+        #                 self.needs_action.append(
+        #                     GrantAccess(
+        #                         signed_agreement=signed_agreement,
+        #                         note=self.VALID_COMPONENT_AGREEMENT,
+        #                     )
+        #                 )
+        #                 return
+        #         else:
+        #             if in_cdsa_group:
+        #                 self.needs_action.append(
+        #                     RemoveAccess(
+        #                         signed_agreement=signed_agreement,
+        #                         note=self.PRIMARY_NOT_VALID,
+        #                     )
+        #                 )
+        #                 return
+        #             else:
+        #                 self.verified.append(
+        #                     VerifiedNoAccess(
+        #                         signed_agreement=signed_agreement,
+        #                         note=self.PRIMARY_NOT_VALID,
+        #                     )
+        #                 )
+        #                 return
+        #     else:
+        #         if in_cdsa_group:
+        #             self.needs_action.append(
+        #                 RemoveAccess(
+        #                     signed_agreement=signed_agreement,
+        #                     note=self.INVALID_AGREEMENT_VERSION,
+        #                 )
+        #             )
+        #             return
+        #         else:
+        #             self.verified.append(
+        #                 VerifiedNoAccess(
+        #                     signed_agreement=signed_agreement,
+        #                     note=self.INVALID_AGREEMENT_VERSION,
+        #                 )
+        #             )
+        #             return
+        # else:
+        #     if in_cdsa_group:
+        #         self.errors.append(
+        #             RemoveAccess(
+        #                 signed_agreement=signed_agreement,
+        #                 note=self.NO_PRIMARY_AGREEMENT,
+        #             )
+        #         )
+        #         return
+        #     else:
+        #         self.verified.append(
+        #             VerifiedNoAccess(
+        #                 signed_agreement=signed_agreement,
+        #                 note=self.NO_PRIMARY_AGREEMENT,
+        #             )
+        #         )
+        #         return
+
         # If we made it this far in audit, some other case happened - log it as an error.
         # Haven't figured out a test for this because it is unexpected.
         self.errors.append(  # pragma: no cover
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 2e51f5ce..336525e9 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -10,6 +10,7 @@
 
 from primed.primed_anvil.tests.factories import StudyFactory, StudySiteFactory
 
+from .. import models
 from ..audit import signed_agreement_audit, workspace_audit
 from . import factories
 
@@ -201,6 +202,46 @@ def test_member_primary_invalid_version_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
+    def test_member_primary_valid_not_active_in_group(self):
+        """Member primary agreement with valid version but isn't active, in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
+    def test_member_primary_valid_not_active_not_in_group(self):
+        """Member primary agreement with valid version but isn't active, not in CDSA group."""
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
     def test_member_component_has_primary_in_group(self):
         """Member component agreement, with valid version, with primary with valid version, in CDSA group."""
         study_site = StudySiteFactory.create()
@@ -245,6 +286,54 @@ def test_member_component_has_primary_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
 
+    def test_member_component_inactive_has_primary_in_group(self):
+        """Member component agreement, inactive, with valid version, with primary with valid version, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
+    def test_member_component_inactive_has_primary_not_in_group(self):
+        """Member component agreement, inactive, with valid version, with valid active primary, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(study_site=study_site)
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False,
+            study_site=study_site,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
     def test_member_component_has_primary_with_invalid_version_in_group(self):
         """Member component agreement, with valid version, with primary with invalid version, in CDSA group."""
         study_site = StudySiteFactory.create()
@@ -295,6 +384,56 @@ def test_member_component_has_primary_with_invalid_version_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
 
+    def test_member_component_has_inactive_primary_in_group(self):
+        """Member component agreement, with valid version, with inactive primary, in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(
+            study_site=study_site,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
+    def test_member_component_has_inactive_primary_not_in_group(self):
+        """Member component agreement, with valid version, with inactive primary, not in CDSA group."""
+        study_site = StudySiteFactory.create()
+        factories.MemberAgreementFactory.create(
+            study_site=study_site,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        this_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__is_primary=False, study_site=study_site
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
     def test_member_component_no_primary_in_group(self):
         """Member component agreement, with valid version, with no primary, in CDSA group."""
         study_site = StudySiteFactory.create()
@@ -555,6 +694,46 @@ def test_data_affiliate_primary_invalid_version_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
+    def test_data_affiliate_primary_valid_not_active_in_group(self):
+        """Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
+    def test_data_affiliate_primary_valid_not_active_not_in_group(self):
+        """Data affiliate primary agreement with valid version but isn't active, not in CDSA group."""
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
     def test_data_affiliate_component_has_primary_in_group(self):
         """Data affiliate component agreement, with valid version, with primary with valid version, in CDSA group."""
         study = StudyFactory.create()
@@ -647,6 +826,56 @@ def test_data_affiliate_has_primary_with_invalid_version_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
 
+    def test_data_affiliate_component_has_inactive_primary_in_group(self):
+        """Data Affiliate component agreement, with valid version, with inactive primary, in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
+    def test_data_affiliate_component_has_inactive_primary_not_in_group(self):
+        """Data Affiliate component agreement, with valid version, with inactive primary, not in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+
     def test_data_affiliate_component_no_primary_in_group(self):
         """Data affiliate component agreement, with valid version, with no primary, in CDSA group."""
         study = StudyFactory.create()
@@ -911,6 +1140,46 @@ def test_non_data_affiliate_primary_invalid_version_not_in_group(self):
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
         self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
 
+    def test_non_data_affiliate_primary_valid_not_active_in_group(self):
+        """Non Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
+    def test_non_data_affiliate_primary_valid_not_active_not_in_group(self):
+        """Non data affiliate primary agreement with valid version but isn't active, not in CDSA group."""
+        this_agreement = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
     def test_non_data_affiliate_component_in_cdsa_group(self):
         """Non data affiliate component agreement."""
         this_agreement = factories.NonDataAffiliateAgreementFactory.create(

From 6ac2df505fd39d6c28384cfc790fac1977db4652 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 14:09:18 -0700
Subject: [PATCH 40/53] Add status check into CDSAWorkspace access audit

In addition to checking if the workspace has a valid CDSA, also check
that that CDSA is active.
---
 primed/cdsa/audit/workspace_audit.py |  15 ++--
 primed/cdsa/tests/test_audit.py      | 102 ++++++++++++++++++++++++++-
 2 files changed, 109 insertions(+), 8 deletions(-)

diff --git a/primed/cdsa/audit/workspace_audit.py b/primed/cdsa/audit/workspace_audit.py
index e5a8f667..693c973c 100644
--- a/primed/cdsa/audit/workspace_audit.py
+++ b/primed/cdsa/audit/workspace_audit.py
@@ -128,11 +128,13 @@ class WorkspaceAccessAudit:
     """Audit for CDSA Workspaces."""
 
     # Access verified.
-    VALID_PRIMARY_AGREEMENT = "Valid primary CDSA."
+    VALID_PRIMARY_AGREEMENT = "Valid, active primary CDSA."
 
     # Allowed reasons for no access.
-    NO_PRIMARY_AGREEMENT = "No primary CDSA for this study exists."
-    INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
+    NO_PRIMARY_AGREEMENT = "No primary CDSA for this study."
+    INVALID_PRIMARY_AGREEMENT = (
+        "Primary CDSA for this study is either invalid or inactive."
+    )
 
     # Other errors
     ERROR_OTHER_CASE = "Workspace did not match any expected situations."
@@ -165,7 +167,8 @@ def _audit_workspace(self, workspace):
         if primary_exists:
             primary_agreement = (
                 primary_qs.filter(
-                    signed_agreement__version__major_version__is_valid=True
+                    signed_agreement__version__major_version__is_valid=True,
+                    signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
                 )
                 .order_by(
                     "-signed_agreement__version__major_version__version",
@@ -198,7 +201,7 @@ def _audit_workspace(self, workspace):
                         RemoveAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.INVALID_AGREEMENT_VERSION,
+                            note=self.INVALID_PRIMARY_AGREEMENT,
                         )
                     )
                     return
@@ -207,7 +210,7 @@ def _audit_workspace(self, workspace):
                         VerifiedNoAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.INVALID_AGREEMENT_VERSION,
+                            note=self.INVALID_PRIMARY_AGREEMENT,
                         )
                     )
                     return
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 336525e9..7deacb24 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -1530,7 +1530,7 @@ def test_primary_invalid_version_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
 
     def test_primary_invalid_version_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
@@ -1552,7 +1552,51 @@ def test_primary_invalid_version_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.RemoveAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+
+    def test_primary_inactive_not_in_auth_domain(self):
+        workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            study=workspace.study,
+        )
+        # Do not add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+
+    def test_primary_inactive_in_auth_domain(self):
+        workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            study=workspace.study,
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.RemoveAccess)
+        self.assertIsNone(record.data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
 
     def test_component_agreement_not_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1728,6 +1772,60 @@ def test_two_primary_one_valid_one_invalid_not_in_auth_domain(self):
         self.assertEqual(record.workspace, workspace)
         self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
 
+    def test_two_primary_one_active_one_inactive_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
+    def test_two_primary_one_active_one_inactive_not_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+        )
+        # Do not add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.GrantAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+
     def test_no_workspaces(self):
         """Audit works when there are no workspaces."""
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()

From 5f79c6b2c5075b8d10bb83c94dc73492707f9246 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Tue, 19 Sep 2023 16:20:03 -0700
Subject: [PATCH 41/53] Add view to update a SignedAgreement status

Add a view that updates the status of a SignedAgreement. Add three
different urls that use this view, one for each agreement type. Note
that the the different urls need to pass the correct agreement_type
as a kwarg to the view. I decided to do this because then the urls
are more consistent with the detail views, eg:
cdsa/signed_agreements/members/1 (for the detail view)
and
cdsa/signed_agreements/members/1/update (for the update view)

Also add a form that is used in this view, tests for the form, and
tests for the view.
---
 primed/cdsa/forms.py                          |  10 +
 primed/cdsa/tests/test_forms.py               |  42 ++
 primed/cdsa/tests/test_views.py               | 480 ++++++++++++++++++
 primed/cdsa/urls.py                           |  20 +-
 primed/cdsa/views.py                          |  27 +-
 .../cdsa/signedagreement_status_update.html   |  46 ++
 6 files changed, 623 insertions(+), 2 deletions(-)
 create mode 100644 primed/templates/cdsa/signedagreement_status_update.html

diff --git a/primed/cdsa/forms.py b/primed/cdsa/forms.py
index f3820344..2e0c1ec2 100644
--- a/primed/cdsa/forms.py
+++ b/primed/cdsa/forms.py
@@ -43,6 +43,16 @@ class Meta:
         }
 
 
+class SignedAgreementStatusForm(forms.ModelForm):
+    """Form to update the status of a SignedAgreement."""
+
+    class Meta:
+        model = models.SignedAgreement
+        fields = ("status",)
+        help_texts = {"status": """The status of this Signed Agreement."""}
+        widgets = {"status": forms.RadioSelect}
+
+
 class MemberAgreementForm(forms.ModelForm):
     class Meta:
         model = models.MemberAgreement
diff --git a/primed/cdsa/tests/test_forms.py b/primed/cdsa/tests/test_forms.py
index 7b191e34..09aac23e 100644
--- a/primed/cdsa/tests/test_forms.py
+++ b/primed/cdsa/tests/test_forms.py
@@ -223,6 +223,48 @@ def test_invalid_version(self):
         self.assertIn("valid choice", form.errors["version"][0])
 
 
+class SignedAgreementStatusFormTest(TestCase):
+    """Tests for the SignedAgreementStatusForm class."""
+
+    form_class = forms.SignedAgreementStatusForm
+
+    def setUp(self):
+        """Create related objects for use in the form."""
+        self.representative = UserFactory.create()
+        self.agreement_version = factories.AgreementVersionFactory.create()
+        self.signed_agreement = factories.SignedAgreementFactory.create()
+
+    def test_valid(self):
+        """Form is valid with necessary input."""
+        form_data = {
+            "status": models.SignedAgreement.StatusChoices.ACTIVE,
+        }
+        form = self.form_class(data=form_data)
+        self.assertTrue(form.is_valid())
+
+    def test_missing_status(self):
+        """Form is invalid when missing status."""
+        form_data = {}
+        form = self.form_class(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("status", form.errors)
+        self.assertEqual(len(form.errors["status"]), 1)
+        self.assertIn("required", form.errors["status"][0])
+
+    def test_invalid_status(self):
+        """Cannot select a status that doesn't exist."""
+        self.agreement_version.major_version.is_valid = False
+        self.agreement_version.major_version.save()
+        form_data = {"status": "foo"}
+        form = self.form_class(data=form_data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("status", form.errors)
+        self.assertEqual(len(form.errors["status"]), 1)
+        self.assertIn("valid choice", form.errors["status"][0])
+
+
 class MemberAgreementFormTest(TestCase):
     """Tests for the MemberAgreementForm class."""
 
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 88b8bb8f..45cf236d 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -527,6 +527,486 @@ def test_workspace_table_three(self):
         self.assertEqual(len(response.context_data["table"].rows), 3)
 
 
+class SignedAgreementStatusUpdateMemberTest(TestCase):
+    """Tests for the SignedAgreementStatusUpdate view with a MemberAgreement."""
+
+    def setUp(self):
+        """Set up test class."""
+        super().setUp()
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permissions.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:signed_agreements:members:update", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.SignedAgreementStatusUpdate.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(1))
+        self.assertRedirects(
+            response, resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(1)
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        instance = factories.MemberAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_with_view_permission(self):
+        """Raises permission denied if user has only view permission."""
+        user_with_view_perm = User.objects.create_user(
+            username="test-other", password="test-other"
+        )
+        user_with_view_perm.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_with_view_perm
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_does_not_exist(self):
+        """Raises Http404 if object does not exist."""
+        request = self.factory.get(self.get_url(1))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_different_agreement_type(self):
+        """Raises Http404 if object has a different agreement type."""
+        instance = factories.DataAffiliateAgreementFactory.create()
+        request = self.factory.get(self.get_url(instance.signed_agreement.cc_id))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=instance.signed_agreement.cc_id)
+
+    def test_has_form_in_context(self):
+        """Response includes a form."""
+        instance = factories.MemberAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertTrue("form" in response.context_data)
+        self.assertIsInstance(
+            response.context_data["form"], forms.SignedAgreementStatusForm
+        )
+
+    def test_can_modify_status(self):
+        """Can change the status."""
+        instance = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertEqual(response.status_code, 302)
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.REPLACED,
+        )
+
+    def test_invalid_status(self):
+        """Can change the status."""
+        instance = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id), {"status": "foo"}
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("form", response.context)
+        form = response.context_data["form"]
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("status", form.errors)
+        self.assertEqual(len(form.errors["status"]), 1)
+        self.assertIn("valid choice", form.errors["status"][0])
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.ACTIVE,
+        )
+
+    def test_success_message(self):
+        """Response includes a success message if successful."""
+        instance = factories.MemberAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            follow=True,
+        )
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.SignedAgreementStatusUpdate.success_message, str(messages[0])
+        )
+
+    def test_redirects_to_object_detail(self):
+        """After successfully creating an object, view redirects to the object's detail page."""
+        # This needs to use the client because the RequestFactory doesn't handle redirects.
+        instance = factories.MemberAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertRedirects(response, instance.get_absolute_url())
+
+
+class SignedAgreementStatusUpdateDataAffiliateTest(TestCase):
+    """Tests for the SignedAgreementStatusUpdate view with a DataAffiliateAgreement."""
+
+    def setUp(self):
+        """Set up test class."""
+        super().setUp()
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permissions.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:signed_agreements:data_affiliates:update", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.SignedAgreementStatusUpdate.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(1))
+        self.assertRedirects(
+            response, resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(1)
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        instance = factories.DataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_with_view_permission(self):
+        """Raises permission denied if user has only view permission."""
+        user_with_view_perm = User.objects.create_user(
+            username="test-other", password="test-other"
+        )
+        user_with_view_perm.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_with_view_perm
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_does_not_exist(self):
+        """Raises Http404 if object does not exist."""
+        request = self.factory.get(self.get_url(1))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_different_agreement_type(self):
+        """Raises Http404 if object has a different agreement type."""
+        instance = factories.MemberAgreementFactory.create()
+        request = self.factory.get(self.get_url(instance.signed_agreement.cc_id))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=instance.signed_agreement.cc_id)
+
+    def test_has_form_in_context(self):
+        """Response includes a form."""
+        instance = factories.DataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertTrue("form" in response.context_data)
+        self.assertIsInstance(
+            response.context_data["form"], forms.SignedAgreementStatusForm
+        )
+
+    def test_can_modify_status(self):
+        """Can change the status."""
+        instance = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertEqual(response.status_code, 302)
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.REPLACED,
+        )
+
+    def test_invalid_status(self):
+        """Can change the status."""
+        instance = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id), {"status": "foo"}
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("form", response.context)
+        form = response.context_data["form"]
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("status", form.errors)
+        self.assertEqual(len(form.errors["status"]), 1)
+        self.assertIn("valid choice", form.errors["status"][0])
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.ACTIVE,
+        )
+
+    def test_success_message(self):
+        """Response includes a success message if successful."""
+        instance = factories.DataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            follow=True,
+        )
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.SignedAgreementStatusUpdate.success_message, str(messages[0])
+        )
+
+    def test_redirects_to_object_detail(self):
+        """After successfully creating an object, view redirects to the object's detail page."""
+        # This needs to use the client because the RequestFactory doesn't handle redirects.
+        instance = factories.DataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertRedirects(response, instance.get_absolute_url())
+
+
+class SignedAgreementStatusUpdateNonDataAffiliateTest(TestCase):
+    """Tests for the SignedAgreementStatusUpdate view with a NonDataAffiliateAgreement."""
+
+    def setUp(self):
+        """Set up test class."""
+        super().setUp()
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permissions.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:signed_agreements:non_data_affiliates:update", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.SignedAgreementStatusUpdate.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(1))
+        self.assertRedirects(
+            response, resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(1)
+        )
+
+    def test_status_code_with_user_permission(self):
+        """Returns successful response code."""
+        instance = factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_with_view_permission(self):
+        """Raises permission denied if user has only view permission."""
+        user_with_view_perm = User.objects.create_user(
+            username="test-other", password="test-other"
+        )
+        user_with_view_perm.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_with_view_perm
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_does_not_exist(self):
+        """Raises Http404 if object does not exist."""
+        request = self.factory.get(self.get_url(1))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=1)
+
+    def test_object_different_agreement_type(self):
+        """Raises Http404 if object has a different agreement type."""
+        instance = factories.MemberAgreementFactory.create()
+        request = self.factory.get(self.get_url(instance.signed_agreement.cc_id))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, cc_id=instance.signed_agreement.cc_id)
+
+    def test_has_form_in_context(self):
+        """Response includes a form."""
+        instance = factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.signed_agreement.cc_id))
+        self.assertTrue("form" in response.context_data)
+        self.assertIsInstance(
+            response.context_data["form"], forms.SignedAgreementStatusForm
+        )
+
+    def test_can_modify_status(self):
+        """Can change the status."""
+        instance = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertEqual(response.status_code, 302)
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.REPLACED,
+        )
+
+    def test_invalid_status(self):
+        """Can change the status."""
+        instance = factories.NonDataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id), {"status": "foo"}
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("form", response.context)
+        form = response.context_data["form"]
+        self.assertFalse(form.is_valid())
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn("status", form.errors)
+        self.assertEqual(len(form.errors["status"]), 1)
+        self.assertIn("valid choice", form.errors["status"][0])
+        instance.refresh_from_db()
+        self.assertEqual(
+            instance.signed_agreement.status,
+            models.SignedAgreement.StatusChoices.ACTIVE,
+        )
+
+    def test_success_message(self):
+        """Response includes a success message if successful."""
+        instance = factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            follow=True,
+        )
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.SignedAgreementStatusUpdate.success_message, str(messages[0])
+        )
+
+    def test_redirects_to_object_detail(self):
+        """After successfully creating an object, view redirects to the object's detail page."""
+        # This needs to use the client because the RequestFactory doesn't handle redirects.
+        instance = factories.NonDataAffiliateAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.get_url(instance.signed_agreement.cc_id),
+            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+        )
+        self.assertRedirects(response, instance.get_absolute_url())
+
+
 class MemberAgreementCreateTest(AnVILAPIMockTestMixin, TestCase):
     """Tests for the MemberAgreementCreate view."""
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index e1b05873..b35c4ef5 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -1,6 +1,6 @@
 from django.urls import include, path
 
-from . import views
+from . import models, views
 
 app_name = "cdsa"
 
@@ -29,6 +29,12 @@
         path("", views.MemberAgreementList.as_view(), name="list"),
         path("new/", views.MemberAgreementCreate.as_view(), name="new"),
         path("<int:cc_id>/", views.MemberAgreementDetail.as_view(), name="detail"),
+        path(
+            "<int:cc_id>/update/",
+            views.SignedAgreementStatusUpdate.as_view(),
+            {"agreement_type": models.SignedAgreement.MEMBER},
+            name="update",
+        ),
     ],
     "members",
 )
@@ -40,6 +46,12 @@
         path(
             "<int:cc_id>/", views.DataAffiliateAgreementDetail.as_view(), name="detail"
         ),
+        path(
+            "<int:cc_id>/update/",
+            views.SignedAgreementStatusUpdate.as_view(),
+            {"agreement_type": models.SignedAgreement.DATA_AFFILIATE},
+            name="update",
+        ),
     ],
     "data_affiliates",
 )
@@ -53,6 +65,12 @@
             views.NonDataAffiliateAgreementDetail.as_view(),
             name="detail",
         ),
+        path(
+            "<int:cc_id>/update/",
+            views.SignedAgreementStatusUpdate.as_view(),
+            {"agreement_type": models.SignedAgreement.NON_DATA_AFFILIATE},
+            name="update",
+        ),
     ],
     "non_data_affiliates",
 )
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 22a74823..1e78d57e 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -15,7 +15,7 @@
 from django.http import Http404, HttpResponseRedirect
 from django.urls import reverse
 from django.utils.translation import ugettext_lazy as _
-from django.views.generic import DetailView, FormView, TemplateView
+from django.views.generic import DetailView, FormView, TemplateView, UpdateView
 from django_tables2 import MultiTableMixin, SingleTableMixin, SingleTableView
 
 from . import forms, helpers, models, tables
@@ -309,6 +309,31 @@ class MemberAgreementList(AnVILConsortiumManagerViewRequired, SingleTableView):
     table_class = tables.MemberAgreementTable
 
 
+class SignedAgreementStatusUpdate(
+    AnVILConsortiumManagerEditRequired, SuccessMessageMixin, UpdateView
+):
+
+    model = models.SignedAgreement
+    form_class = forms.SignedAgreementStatusForm
+    template_name = "cdsa/signedagreement_status_update.html"
+    agreement_type = None
+    success_message = "Successfully updated Signed Agreement status."
+
+    def get_object(self, queryset=None):
+        """Look up the agreement by agreement_type_indicator and CDSA cc_id."""
+        queryset = self.get_queryset()
+        try:
+            obj = queryset.get(
+                cc_id=self.kwargs.get("cc_id"), type=self.kwargs.get("agreement_type")
+            )
+        except queryset.model.DoesNotExist:
+            raise Http404(
+                "No %(verbose_name)s found matching the query"
+                % {"verbose_name": queryset.model._meta.verbose_name}
+            )
+        return obj
+
+
 class DataAffiliateAgreementDetail(AnVILConsortiumManagerViewRequired, DetailView):
     """View to show details about a `DataAffiliateAgreement`."""
 
diff --git a/primed/templates/cdsa/signedagreement_status_update.html b/primed/templates/cdsa/signedagreement_status_update.html
new file mode 100644
index 00000000..e3e2b418
--- /dev/null
+++ b/primed/templates/cdsa/signedagreement_status_update.html
@@ -0,0 +1,46 @@
+{% extends "anvil_consortium_manager/__object_detail.html" %}
+{% load static %}
+{% load crispy_forms_tags %}
+
+{% block title %}Signed Agreement status update{% endblock title %}
+
+{% block panel %}
+<dl class="row">
+  <dt class="col-sm-2">Coordinating Center ID</dt> <dd class="col-sm-9">{{ object.cc_id }}</dd>
+  <dt class="col-sm-2">Representative</dt> <dd class="col-sm-9">
+    <a href="{{ object.representative.get_absolute_url }}">{{ object.representative.name }}</a>
+  </dd>
+  <dt class="col-sm-2">Representative role</dt> <dd class="col-sm-9">{{ object.representative_role }}</dd>
+  <dt class="col-sm-2">Signing institution</dt> <dd class="col-sm-9">{{ object.signing_institution }}</dd>
+  <dt class="col-sm-2">Primary?</dt> <dd class="col-sm-9">{{ object.is_primary }}</dd>
+  <dt class="col-sm-2">Agreement version</dt> <dd class="col-sm-9">
+    <a href="{{ object.version.get_absolute_url }}">{{ object.version }}</a>
+  </dd>
+  <dt class="col-sm-2">Date signed</dt> <dd class="col-sm-9">{{ object.date_signed }}</dd>
+
+  <dt class="col-sm-2">Agreement group</dt> <dd class="col-sm-9">
+    <a href="{{ object.study_site.agreement_group.get_absolute_url }}">{{ object.agreement_group }}</a>
+  </dd>
+  <dt class="col-sm-2">AnVIL access group</dt><dd class="col-sm-9">
+    <a href="{{ object.anvil_access_group.get_absolute_url }}">{{ object.anvil_access_group }}</a>
+  </dd>
+</dl>
+{% endblock panel %}
+
+{% block after_panel %}
+<div>
+  <form method="post">
+
+    {% csrf_token %}
+    {{ form|crispy }}
+    {{ formset|crispy }}
+
+    <button type="submit" class="btn btn-success">Save</button>
+  </form>
+</div>
+{% endblock after_panel %}
+
+
+{% block inline_javascript %}
+  {{ form.media }}
+{% endblock inline_javascript %}

From f266c7eed6d3898307674a77325d4704bfb7d963 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 20 Sep 2023 13:53:51 -0700
Subject: [PATCH 42/53] Change allowed status options to ACTIVE and WITHDRAWN

---
 primed/cdsa/models.py            |  2 +-
 primed/cdsa/tests/test_audit.py  | 32 ++++++++++++++++----------------
 primed/cdsa/tests/test_models.py |  4 ++--
 primed/cdsa/tests/test_views.py  | 24 ++++++++++++------------
 4 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 8a694070..6e2d1d84 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -103,7 +103,7 @@ class SignedAgreementStatusMixin:
 
     class StatusChoices(models.TextChoices):
         ACTIVE = "active", "Active"
-        REPLACED = "replaced", "Replaced"
+        WITHDRAWN = "withdrawn", "Withdrawn"
 
     STATUS = StatusChoices.choices
 
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 7deacb24..09730684 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -205,7 +205,7 @@ def test_member_primary_invalid_version_not_in_group(self):
     def test_member_primary_valid_not_active_in_group(self):
         """Member primary agreement with valid version but isn't active, in CDSA group."""
         this_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -225,7 +225,7 @@ def test_member_primary_valid_not_active_in_group(self):
     def test_member_primary_valid_not_active_not_in_group(self):
         """Member primary agreement with valid version but isn't active, not in CDSA group."""
         this_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -293,7 +293,7 @@ def test_member_component_inactive_has_primary_in_group(self):
         this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False,
             study_site=study_site,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -317,7 +317,7 @@ def test_member_component_inactive_has_primary_not_in_group(self):
         this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False,
             study_site=study_site,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -389,7 +389,7 @@ def test_member_component_has_inactive_primary_in_group(self):
         study_site = StudySiteFactory.create()
         factories.MemberAgreementFactory.create(
             study_site=study_site,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False, study_site=study_site
@@ -414,7 +414,7 @@ def test_member_component_has_inactive_primary_not_in_group(self):
         study_site = StudySiteFactory.create()
         factories.MemberAgreementFactory.create(
             study_site=study_site,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__is_primary=False, study_site=study_site
@@ -697,7 +697,7 @@ def test_data_affiliate_primary_invalid_version_not_in_group(self):
     def test_data_affiliate_primary_valid_not_active_in_group(self):
         """Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -717,7 +717,7 @@ def test_data_affiliate_primary_valid_not_active_in_group(self):
     def test_data_affiliate_primary_valid_not_active_not_in_group(self):
         """Data affiliate primary agreement with valid version but isn't active, not in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -831,7 +831,7 @@ def test_data_affiliate_component_has_inactive_primary_in_group(self):
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(
             study=study,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False, study=study
@@ -856,7 +856,7 @@ def test_data_affiliate_component_has_inactive_primary_not_in_group(self):
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(
             study=study,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False, study=study
@@ -1143,7 +1143,7 @@ def test_non_data_affiliate_primary_invalid_version_not_in_group(self):
     def test_non_data_affiliate_primary_valid_not_active_in_group(self):
         """Non Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
         this_agreement = factories.NonDataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -1163,7 +1163,7 @@ def test_non_data_affiliate_primary_valid_not_active_in_group(self):
     def test_non_data_affiliate_primary_valid_not_active_not_in_group(self):
         """Non data affiliate primary agreement with valid version but isn't active, not in CDSA group."""
         this_agreement = factories.NonDataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -1557,7 +1557,7 @@ def test_primary_invalid_version_in_auth_domain(self):
     def test_primary_inactive_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
         factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
             study=workspace.study,
         )
         # Do not add the CDSA group to the auth domain.
@@ -1579,7 +1579,7 @@ def test_primary_inactive_not_in_auth_domain(self):
     def test_primary_inactive_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
         factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
             study=workspace.study,
         )
         # Add the CDSA group to the auth domain.
@@ -1777,7 +1777,7 @@ def test_two_primary_one_active_one_inactive_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         factories.DataAffiliateAgreementFactory.create(
             study=study,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
             study=study,
@@ -1804,7 +1804,7 @@ def test_two_primary_one_active_one_inactive_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         factories.DataAffiliateAgreementFactory.create(
             study=study,
-            signed_agreement__status=models.SignedAgreement.StatusChoices.REPLACED,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
             study=study,
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 7db9f63d..9a961b9e 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -295,9 +295,9 @@ def test_status_field(self):
         instance.full_clean()
         # other choices
         instance = factories.SignedAgreementFactory.create(
-            status=models.SignedAgreement.StatusChoices.REPLACED
+            status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
-        self.assertEqual(instance.status, instance.StatusChoices.REPLACED)
+        self.assertEqual(instance.status, instance.StatusChoices.WITHDRAWN)
         instance.full_clean()
         # not allowed
         instance = factories.SignedAgreementFactory.create(status="foo")
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 45cf236d..b6d35f2a 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -628,13 +628,13 @@ def test_can_modify_status(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertEqual(response.status_code, 302)
         instance.refresh_from_db()
         self.assertEqual(
             instance.signed_agreement.status,
-            models.SignedAgreement.StatusChoices.REPLACED,
+            models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
 
     def test_invalid_status(self):
@@ -666,7 +666,7 @@ def test_success_message(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
             follow=True,
         )
         messages = [m.message for m in get_messages(response.wsgi_request)]
@@ -682,7 +682,7 @@ def test_redirects_to_object_detail(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertRedirects(response, instance.get_absolute_url())
 
@@ -788,13 +788,13 @@ def test_can_modify_status(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertEqual(response.status_code, 302)
         instance.refresh_from_db()
         self.assertEqual(
             instance.signed_agreement.status,
-            models.SignedAgreement.StatusChoices.REPLACED,
+            models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
 
     def test_invalid_status(self):
@@ -826,7 +826,7 @@ def test_success_message(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
             follow=True,
         )
         messages = [m.message for m in get_messages(response.wsgi_request)]
@@ -842,7 +842,7 @@ def test_redirects_to_object_detail(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertRedirects(response, instance.get_absolute_url())
 
@@ -948,13 +948,13 @@ def test_can_modify_status(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertEqual(response.status_code, 302)
         instance.refresh_from_db()
         self.assertEqual(
             instance.signed_agreement.status,
-            models.SignedAgreement.StatusChoices.REPLACED,
+            models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
 
     def test_invalid_status(self):
@@ -986,7 +986,7 @@ def test_success_message(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
             follow=True,
         )
         messages = [m.message for m in get_messages(response.wsgi_request)]
@@ -1002,7 +1002,7 @@ def test_redirects_to_object_detail(self):
         self.client.force_login(self.user)
         response = self.client.post(
             self.get_url(instance.signed_agreement.cc_id),
-            {"status": models.SignedAgreement.StatusChoices.REPLACED},
+            {"status": models.SignedAgreement.StatusChoices.WITHDRAWN},
         )
         self.assertRedirects(response, instance.get_absolute_url())
 

From 19328c79dc4499820d6c9e03c9eabd39f888460a Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 20 Sep 2023 14:46:36 -0700
Subject: [PATCH 43/53] Add the LAPSED status to SignedAgreement status choices

This status is intended to be used for SignedAgreements whose
major version became invalid but were not withdrawn.
---
 primed/cdsa/models.py            | 1 +
 primed/cdsa/tests/test_models.py | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 6e2d1d84..8fea2036 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -104,6 +104,7 @@ class SignedAgreementStatusMixin:
     class StatusChoices(models.TextChoices):
         ACTIVE = "active", "Active"
         WITHDRAWN = "withdrawn", "Withdrawn"
+        LAPSED = "lapsed", "Lapsed"
 
     STATUS = StatusChoices.choices
 
diff --git a/primed/cdsa/tests/test_models.py b/primed/cdsa/tests/test_models.py
index 9a961b9e..32b35cd2 100644
--- a/primed/cdsa/tests/test_models.py
+++ b/primed/cdsa/tests/test_models.py
@@ -299,6 +299,12 @@ def test_status_field(self):
         )
         self.assertEqual(instance.status, instance.StatusChoices.WITHDRAWN)
         instance.full_clean()
+        instance = factories.SignedAgreementFactory.create(
+            status=models.SignedAgreement.StatusChoices.LAPSED
+        )
+        self.assertEqual(instance.status, instance.StatusChoices.LAPSED)
+        instance.full_clean()
+
         # not allowed
         instance = factories.SignedAgreementFactory.create(status="foo")
         with self.assertRaises(ValidationError):

From 2e5cb62cf01e61ba15f64048def2942256da3ffa Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 20 Sep 2023 14:48:31 -0700
Subject: [PATCH 44/53] Add docstrings to SignedAgreement statuses

---
 primed/cdsa/models.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 8fea2036..9107ab81 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -103,8 +103,14 @@ class SignedAgreementStatusMixin:
 
     class StatusChoices(models.TextChoices):
         ACTIVE = "active", "Active"
+        """SignedAgreements that are currently active."""
+
         WITHDRAWN = "withdrawn", "Withdrawn"
+        """SignedAgreements that have been withdrawn for some reason (e.g., PI changed institution,
+        study no longer wanted to participate.)"""
+
         LAPSED = "lapsed", "Lapsed"
+        """SignedAgreements from a AgreementMajorVersion that is no longer valid."""
 
     STATUS = StatusChoices.choices
 

From 12fd6a0b55a87531b5b314c228c12feb5a89afc5 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Wed, 20 Sep 2023 16:44:55 -0700
Subject: [PATCH 45/53] Rework audit such that AgreementMajorVersion is_valid
 is ignored

If the major version associated with a signed agreement is not valid
but the SignedAgreement is still active, still allow that
SignedAgreement to have access to the CDSA (and any workspaces associated
with that DataAffiliate CDSA's study). We decided that the view to
invalidate an AgreementMajorVersion instance would also set the
status to LAPSED for all SignedAgreements associated with that version.
This gives us additional flexibility if we need in the future (eg, we
can change a LAPSED SignedAgreement to ACTIVE if we need to extend
their access for some reason). Therefore, we only need to consider
the status of the SignedAgreement (and its associated primary, if
applicable).
---
 primed/cdsa/audit/signed_agreement_audit.py | 203 +++------
 primed/cdsa/audit/workspace_audit.py        |  15 +-
 primed/cdsa/tests/test_audit.py             | 446 ++++++++++++--------
 primed/cdsa/tests/test_views.py             |  12 +-
 4 files changed, 343 insertions(+), 333 deletions(-)

diff --git a/primed/cdsa/audit/signed_agreement_audit.py b/primed/cdsa/audit/signed_agreement_audit.py
index 26f0b909..c264271f 100644
--- a/primed/cdsa/audit/signed_agreement_audit.py
+++ b/primed/cdsa/audit/signed_agreement_audit.py
@@ -126,16 +126,14 @@ class SignedAgreementAccessAudit:
     """Audit for Signed Agreements."""
 
     # Access verified.
-    VALID_PRIMARY_AGREEMENT = "Valid, active primary CDSA."
-    VALID_COMPONENT_AGREEMENT = "Valid, active component CDSA."
+    ACTIVE_PRIMARY_AGREEMENT = "Active primary CDSA."
+    ACTIVE_COMPONENT_AGREEMENT = "Active component CDSA with active primary."
 
     # Allowed reasons for no access.
-    NO_PRIMARY_AGREEMENT = "No primary CDSA for this group exists."
-    PRIMARY_NOT_VALID = (
-        "Primary agreement for this CDSA is either not valid or not active."
-    )
-    INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
     INACTIVE_AGREEMENT = "CDSA is inactive."
+    # INVALID_AGREEMENT_VERSION = "CDSA version is not valid."
+    NO_PRIMARY_AGREEMENT = "No primary CDSA for this group exists."
+    PRIMARY_NOT_ACTIVE = "Primary agreement for this CDSA is not active."
 
     # Other errors
     ERROR_NON_DATA_AFFILIATE_COMPONENT = (
@@ -157,57 +155,39 @@ def _audit_primary_agreement(self, signed_agreement):
         """Audit a single component signed agreement.
 
         The following items are checked:
-        * if the primary agreement is valid.
+        * if the primary agreement is active.
         * if the primary agreement is in the CDSA group.
+
+        This audit does *not* check if the AgreementMajorVersion associated with the SignedAgreement is valid.
         """
-        is_valid = signed_agreement.version.major_version.is_valid
         in_cdsa_group = signed_agreement.is_in_cdsa_group()
         is_active = (
             signed_agreement.status == models.SignedAgreement.StatusChoices.ACTIVE
         )
 
-        if is_valid:
-            if is_active:
-                if in_cdsa_group:
-                    self.verified.append(
-                        VerifiedAccess(
-                            signed_agreement=signed_agreement,
-                            note=self.VALID_PRIMARY_AGREEMENT,
-                        )
-                    )
-                    return
-                else:
-                    self.needs_action.append(
-                        GrantAccess(
-                            signed_agreement=signed_agreement,
-                            note=self.VALID_PRIMARY_AGREEMENT,
-                        )
+        if is_active:
+            if in_cdsa_group:
+                self.verified.append(
+                    VerifiedAccess(
+                        signed_agreement=signed_agreement,
+                        note=self.ACTIVE_PRIMARY_AGREEMENT,
                     )
-                    return
-
+                )
+                return
             else:
-                if in_cdsa_group:
-                    self.needs_action.append(
-                        RemoveAccess(
-                            signed_agreement=signed_agreement,
-                            note=self.INACTIVE_AGREEMENT,
-                        )
-                    )
-                    return
-                else:
-                    self.verified.append(
-                        VerifiedNoAccess(
-                            signed_agreement=signed_agreement,
-                            note=self.INACTIVE_AGREEMENT,
-                        )
+                self.needs_action.append(
+                    GrantAccess(
+                        signed_agreement=signed_agreement,
+                        note=self.ACTIVE_PRIMARY_AGREEMENT,
                     )
-                    return
+                )
+                return
         else:
             if in_cdsa_group:
                 self.needs_action.append(
                     RemoveAccess(
                         signed_agreement=signed_agreement,
-                        note=self.INVALID_AGREEMENT_VERSION,
+                        note=self.INACTIVE_AGREEMENT,
                     )
                 )
                 return
@@ -215,7 +195,7 @@ def _audit_primary_agreement(self, signed_agreement):
                 self.verified.append(
                     VerifiedNoAccess(
                         signed_agreement=signed_agreement,
-                        note=self.INVALID_AGREEMENT_VERSION,
+                        note=self.INACTIVE_AGREEMENT,
                     )
                 )
                 return
@@ -232,12 +212,14 @@ def _audit_component_agreement(self, signed_agreement):
         """Audit a single component signed agreement.
 
         The following items are checked:
-        * If a primary agreement exists.
-        * if the component agreement is valid.
-        * if the corresponding primary is invalid.
-        * if the component agreement is in the CDSA group.
+        * If a primary agreement exists
+        # If the primary agreement is active
+        * if the component agreement is active
+        * if the component agreement is in the CDSA group
+
+        This audit does *not* check if the AgreementMajorVersion associated with either the
+        SignedAgreement or its component is valid.
         """
-        is_valid = signed_agreement.version.major_version.is_valid
         in_cdsa_group = signed_agreement.is_in_cdsa_group()
         is_active = (
             signed_agreement.status == models.SignedAgreement.StatusChoices.ACTIVE
@@ -265,54 +247,35 @@ def _audit_component_agreement(self, signed_agreement):
             )
             return
         primary_exists = primary_qs.exists()
-        primary_valid = primary_qs.filter(
-            version__major_version__is_valid=True,
+        primary_active = primary_qs.filter(
             status=models.SignedAgreement.StatusChoices.ACTIVE,
         ).exists()
 
         if primary_exists:
-            if primary_valid:
-                if is_valid:
-                    if is_active:
-                        if in_cdsa_group:
-                            self.verified.append(
-                                VerifiedAccess(
-                                    signed_agreement=signed_agreement,
-                                    note=self.VALID_COMPONENT_AGREEMENT,
-                                )
-                            )
-                            return
-                        else:
-                            self.needs_action.append(
-                                GrantAccess(
-                                    signed_agreement=signed_agreement,
-                                    note=self.VALID_COMPONENT_AGREEMENT,
-                                )
+            if primary_active:
+                if is_active:
+                    if in_cdsa_group:
+                        self.verified.append(
+                            VerifiedAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.ACTIVE_COMPONENT_AGREEMENT,
                             )
-                            return
+                        )
+                        return
                     else:
-                        if in_cdsa_group:
-                            self.needs_action.append(
-                                RemoveAccess(
-                                    signed_agreement=signed_agreement,
-                                    note=self.INACTIVE_AGREEMENT,
-                                )
-                            )
-                            return
-                        else:
-                            self.verified.append(
-                                VerifiedNoAccess(
-                                    signed_agreement=signed_agreement,
-                                    note=self.INACTIVE_AGREEMENT,
-                                )
+                        self.needs_action.append(
+                            GrantAccess(
+                                signed_agreement=signed_agreement,
+                                note=self.ACTIVE_COMPONENT_AGREEMENT,
                             )
-                            return
+                        )
+                        return
                 else:
                     if in_cdsa_group:
                         self.needs_action.append(
                             RemoveAccess(
                                 signed_agreement=signed_agreement,
-                                note=self.INVALID_AGREEMENT_VERSION,
+                                note=self.INACTIVE_AGREEMENT,
                             )
                         )
                         return
@@ -320,7 +283,7 @@ def _audit_component_agreement(self, signed_agreement):
                         self.verified.append(
                             VerifiedNoAccess(
                                 signed_agreement=signed_agreement,
-                                note=self.INVALID_AGREEMENT_VERSION,
+                                note=self.INACTIVE_AGREEMENT,
                             )
                         )
                         return
@@ -329,7 +292,7 @@ def _audit_component_agreement(self, signed_agreement):
                     self.needs_action.append(
                         RemoveAccess(
                             signed_agreement=signed_agreement,
-                            note=self.PRIMARY_NOT_VALID,
+                            note=self.PRIMARY_NOT_ACTIVE,
                         )
                     )
                     return
@@ -337,7 +300,7 @@ def _audit_component_agreement(self, signed_agreement):
                     self.verified.append(
                         VerifiedNoAccess(
                             signed_agreement=signed_agreement,
-                            note=self.PRIMARY_NOT_VALID,
+                            note=self.PRIMARY_NOT_ACTIVE,
                         )
                     )
                     return
@@ -359,70 +322,6 @@ def _audit_component_agreement(self, signed_agreement):
                 )
                 return
 
-        # if primary_exists:
-        #     if is_valid:
-        #         if primary_valid:
-        #             if in_cdsa_group:
-        #             else:
-        #                 self.needs_action.append(
-        #                     GrantAccess(
-        #                         signed_agreement=signed_agreement,
-        #                         note=self.VALID_COMPONENT_AGREEMENT,
-        #                     )
-        #                 )
-        #                 return
-        #         else:
-        #             if in_cdsa_group:
-        #                 self.needs_action.append(
-        #                     RemoveAccess(
-        #                         signed_agreement=signed_agreement,
-        #                         note=self.PRIMARY_NOT_VALID,
-        #                     )
-        #                 )
-        #                 return
-        #             else:
-        #                 self.verified.append(
-        #                     VerifiedNoAccess(
-        #                         signed_agreement=signed_agreement,
-        #                         note=self.PRIMARY_NOT_VALID,
-        #                     )
-        #                 )
-        #                 return
-        #     else:
-        #         if in_cdsa_group:
-        #             self.needs_action.append(
-        #                 RemoveAccess(
-        #                     signed_agreement=signed_agreement,
-        #                     note=self.INVALID_AGREEMENT_VERSION,
-        #                 )
-        #             )
-        #             return
-        #         else:
-        #             self.verified.append(
-        #                 VerifiedNoAccess(
-        #                     signed_agreement=signed_agreement,
-        #                     note=self.INVALID_AGREEMENT_VERSION,
-        #                 )
-        #             )
-        #             return
-        # else:
-        #     if in_cdsa_group:
-        #         self.errors.append(
-        #             RemoveAccess(
-        #                 signed_agreement=signed_agreement,
-        #                 note=self.NO_PRIMARY_AGREEMENT,
-        #             )
-        #         )
-        #         return
-        #     else:
-        #         self.verified.append(
-        #             VerifiedNoAccess(
-        #                 signed_agreement=signed_agreement,
-        #                 note=self.NO_PRIMARY_AGREEMENT,
-        #             )
-        #         )
-        #         return
-
         # If we made it this far in audit, some other case happened - log it as an error.
         # Haven't figured out a test for this because it is unexpected.
         self.errors.append(  # pragma: no cover
diff --git a/primed/cdsa/audit/workspace_audit.py b/primed/cdsa/audit/workspace_audit.py
index 693c973c..e6ac2fc4 100644
--- a/primed/cdsa/audit/workspace_audit.py
+++ b/primed/cdsa/audit/workspace_audit.py
@@ -128,13 +128,11 @@ class WorkspaceAccessAudit:
     """Audit for CDSA Workspaces."""
 
     # Access verified.
-    VALID_PRIMARY_AGREEMENT = "Valid, active primary CDSA."
+    ACTIVE_PRIMARY_AGREEMENT = "Active primary CDSA."
 
     # Allowed reasons for no access.
     NO_PRIMARY_AGREEMENT = "No primary CDSA for this study."
-    INVALID_PRIMARY_AGREEMENT = (
-        "Primary CDSA for this study is either invalid or inactive."
-    )
+    INACTIVE_PRIMARY_AGREEMENT = "Primary CDSA for this study is inactive."
 
     # Other errors
     ERROR_OTHER_CASE = "Workspace did not match any expected situations."
@@ -167,7 +165,6 @@ def _audit_workspace(self, workspace):
         if primary_exists:
             primary_agreement = (
                 primary_qs.filter(
-                    signed_agreement__version__major_version__is_valid=True,
                     signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
                 )
                 .order_by(
@@ -182,7 +179,7 @@ def _audit_workspace(self, workspace):
                         VerifiedAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.VALID_PRIMARY_AGREEMENT,
+                            note=self.ACTIVE_PRIMARY_AGREEMENT,
                         )
                     )
                     return
@@ -191,7 +188,7 @@ def _audit_workspace(self, workspace):
                         GrantAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.VALID_PRIMARY_AGREEMENT,
+                            note=self.ACTIVE_PRIMARY_AGREEMENT,
                         )
                     )
                     return
@@ -201,7 +198,7 @@ def _audit_workspace(self, workspace):
                         RemoveAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.INVALID_PRIMARY_AGREEMENT,
+                            note=self.INACTIVE_PRIMARY_AGREEMENT,
                         )
                     )
                     return
@@ -210,7 +207,7 @@ def _audit_workspace(self, workspace):
                         VerifiedNoAccess(
                             workspace=workspace,
                             data_affiliate_agreement=primary_agreement,
-                            note=self.INVALID_PRIMARY_AGREEMENT,
+                            note=self.INACTIVE_PRIMARY_AGREEMENT,
                         )
                     )
                     return
diff --git a/primed/cdsa/tests/test_audit.py b/primed/cdsa/tests/test_audit.py
index 09730684..9a85e2e5 100644
--- a/primed/cdsa/tests/test_audit.py
+++ b/primed/cdsa/tests/test_audit.py
@@ -142,7 +142,7 @@ def test_member_primary_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_member_primary_not_in_group(self):
         """Member primary agreement with valid version not in CDSA group."""
@@ -160,10 +160,10 @@ def test_member_primary_not_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_member_primary_invalid_version_in_group(self):
-        """Member primary agreement with invalid version in CDSA group."""
+        """Member primary agreement, active, with invalid version in CDSA group."""
         this_agreement = factories.MemberAgreementFactory.create(
             signed_agreement__version__major_version__is_valid=False
         )
@@ -174,13 +174,13 @@ def test_member_primary_invalid_version_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_member_primary_invalid_version_not_in_group(self):
         """Member primary agreement, with invalid version, not in CDSA group."""
@@ -194,13 +194,13 @@ def test_member_primary_invalid_version_not_in_group(self):
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_member_primary_valid_not_active_in_group(self):
         """Member primary agreement with valid version but isn't active, in CDSA group."""
@@ -262,7 +262,7 @@ def test_member_component_has_primary_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_has_primary_not_in_group(self):
         """Member component agreement, with valid version, with primary with valid version, not in CDSA group."""
@@ -284,7 +284,7 @@ def test_member_component_has_primary_not_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_inactive_has_primary_in_group(self):
         """Member component agreement, inactive, with valid version, with primary with valid version, in CDSA group."""
@@ -335,7 +335,7 @@ def test_member_component_inactive_has_primary_not_in_group(self):
         self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
 
     def test_member_component_has_primary_with_invalid_version_in_group(self):
-        """Member component agreement, with valid version, with primary with invalid version, in CDSA group."""
+        """Member component agreement, with valid version, with active primary with invalid version, in CDSA group."""
         study_site = StudySiteFactory.create()
         factories.MemberAgreementFactory.create(
             study_site=study_site,
@@ -351,16 +351,16 @@ def test_member_component_has_primary_with_invalid_version_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_has_primary_with_invalid_version_not_in_group(self):
-        """Member component agreement, with valid version, with primary with invalid version, not in CDSA group."""
+        """Member component agreement, with valid version, with active primary with invalid version, not in group."""
         study_site = StudySiteFactory.create()
         factories.MemberAgreementFactory.create(
             study_site=study_site,
@@ -376,13 +376,13 @@ def test_member_component_has_primary_with_invalid_version_not_in_group(self):
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_has_inactive_primary_in_group(self):
         """Member component agreement, with valid version, with inactive primary, in CDSA group."""
@@ -407,7 +407,7 @@ def test_member_component_has_inactive_primary_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_ACTIVE)
 
     def test_member_component_has_inactive_primary_not_in_group(self):
         """Member component agreement, with valid version, with inactive primary, not in CDSA group."""
@@ -432,7 +432,7 @@ def test_member_component_has_inactive_primary_not_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_ACTIVE)
 
     def test_member_component_no_primary_in_group(self):
         """Member component agreement, with valid version, with no primary, in CDSA group."""
@@ -492,13 +492,13 @@ def test_member_component_invalid_version_has_primary_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_invalid_version_has_primary_not_in_group(self):
         """Member component agreement, with invalid version, with a valid primary, not in CDSA group."""
@@ -516,13 +516,13 @@ def test_member_component_invalid_version_has_primary_not_in_group(self):
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_invalid_version_has_primary_with_invalid_version_in_group(
         self,
@@ -542,13 +542,13 @@ def test_member_component_invalid_version_has_primary_with_invalid_version_in_gr
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_invalid_version_has_primary_with_invalid_version_not_in_group(
         self,
@@ -568,13 +568,13 @@ def test_member_component_invalid_version_has_primary_with_invalid_version_not_i
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_member_component_invalid_version_no_primary_in_group(self):
         """Member component agreement, with invalid version, with no primary, in CDSA group."""
@@ -619,7 +619,7 @@ def test_member_component_invalid_version_no_primary_not_in_group(self):
         self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_primary_in_group(self):
-        """Data affiliate primary agreement with valid version in CDSA group."""
+        """Member primary agreement with valid version in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create()
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -634,10 +634,10 @@ def test_data_affiliate_primary_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_primary_not_in_group(self):
-        """Data affiliate primary agreement with valid version not in CDSA group."""
+        """Member primary agreement with valid version not in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create()
         # Do not add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -652,10 +652,10 @@ def test_data_affiliate_primary_not_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_primary_invalid_version_in_group(self):
-        """Data affiliate primary agreement with invalid version in CDSA group."""
+        """Member primary agreement, active, with invalid version in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__version__major_version__is_valid=False
         )
@@ -666,16 +666,16 @@ def test_data_affiliate_primary_invalid_version_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_primary_invalid_version_not_in_group(self):
-        """Data affiliate primary agreement, with invalid version, not in CDSA group."""
+        """Member primary agreement, with invalid version, not in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__version__major_version__is_valid=False
         )
@@ -686,16 +686,16 @@ def test_data_affiliate_primary_invalid_version_not_in_group(self):
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_primary_valid_not_active_in_group(self):
-        """Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
+        """Member primary agreement with valid version but isn't active, in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
@@ -715,7 +715,7 @@ def test_data_affiliate_primary_valid_not_active_in_group(self):
         self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
 
     def test_data_affiliate_primary_valid_not_active_not_in_group(self):
-        """Data affiliate primary agreement with valid version but isn't active, not in CDSA group."""
+        """Member primary agreement with valid version but isn't active, not in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
@@ -735,7 +735,7 @@ def test_data_affiliate_primary_valid_not_active_not_in_group(self):
         self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
 
     def test_data_affiliate_component_has_primary_in_group(self):
-        """Data affiliate component agreement, with valid version, with primary with valid version, in CDSA group."""
+        """Member component agreement, with valid version, with primary with valid version, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -754,10 +754,10 @@ def test_data_affiliate_component_has_primary_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_has_primary_not_in_group(self):
-        """Data affiliate component agreement, valid version, with primary with valid version, not in CDSA group."""
+        """Member component agreement, with valid version, with primary with valid version, not in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -776,16 +776,16 @@ def test_data_affiliate_component_has_primary_not_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_COMPONENT_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
-    def test_data_affiliate_component_has_primary_with_invalid_version_in_group(self):
-        """Data affiliate component agreement, valid version, with primary with invalid version, in CDSA group."""
+    def test_data_affiliate_component_inactive_has_primary_in_group(self):
+        """Member component agreement, inactive, with valid version, with primary with valid version, in CDSA group."""
         study = StudyFactory.create()
-        factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=False
-        )
+        factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__is_primary=False, study=study
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         # Add the signed agreement access group to the CDSA group.
         GroupGroupMembershipFactory.create(
@@ -800,16 +800,16 @@ def test_data_affiliate_component_has_primary_with_invalid_version_in_group(self
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
 
-    def test_data_affiliate_has_primary_with_invalid_version_not_in_group(self):
-        """Data affiliate component agreement, valid version, with primary with invalid version, not in CDSA group."""
+    def test_data_affiliate_component_inactive_has_primary_not_in_group(self):
+        """Member component agreement, inactive, with valid version, with valid active primary, not in CDSA group."""
         study = StudyFactory.create()
-        factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=False
-        )
+        factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
-            signed_agreement__is_primary=False, study=study
+            signed_agreement__is_primary=False,
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
         )
         # # Add the signed agreement access group to the CDSA group.
         # GroupGroupMembershipFactory.create(
@@ -824,10 +824,62 @@ def test_data_affiliate_has_primary_with_invalid_version_not_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_AGREEMENT)
+
+    def test_data_affiliate_component_has_primary_with_invalid_version_in_group(self):
+        """Member component agreement, with valid version, with active primary with invalid version, in CDSA group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # Add the signed agreement access group to the CDSA group.
+        GroupGroupMembershipFactory.create(
+            parent_group=self.cdsa_group,
+            child_group=this_agreement.signed_agreement.anvil_access_group,
+        )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
+
+    def test_data_affiliate_component_has_primary_with_invalid_version_not_in_group(
+        self,
+    ):
+        """Member component agreement, with valid version, with active primary with invalid version, not in group."""
+        study = StudyFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__is_primary=False, study=study
+        )
+        # # Add the signed agreement access group to the CDSA group.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=self.cdsa_group,
+        #     child_group=this_agreement.signed_agreement.anvil_access_group,
+        # )
+        cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
+        cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
+        self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_has_inactive_primary_in_group(self):
-        """Data Affiliate component agreement, with valid version, with inactive primary, in CDSA group."""
+        """Member component agreement, with valid version, with inactive primary, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(
             study=study,
@@ -849,10 +901,10 @@ def test_data_affiliate_component_has_inactive_primary_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_ACTIVE)
 
     def test_data_affiliate_component_has_inactive_primary_not_in_group(self):
-        """Data Affiliate component agreement, with valid version, with inactive primary, not in CDSA group."""
+        """Member component agreement, with valid version, with inactive primary, not in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(
             study=study,
@@ -874,10 +926,10 @@ def test_data_affiliate_component_has_inactive_primary_not_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_VALID)
+        self.assertEqual(record.note, cdsa_audit.PRIMARY_NOT_ACTIVE)
 
     def test_data_affiliate_component_no_primary_in_group(self):
-        """Data affiliate component agreement, with valid version, with no primary, in CDSA group."""
+        """Member component agreement, with valid version, with no primary, in CDSA group."""
         study = StudyFactory.create()
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False, study=study
@@ -898,7 +950,7 @@ def test_data_affiliate_component_no_primary_in_group(self):
         self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_component_no_primary_not_in_group(self):
-        """Data affiliate component agreement, with valid version, with no primary, not in CDSA group."""
+        """Member component agreement, with valid version, with no primary, not in CDSA group."""
         study = StudyFactory.create()
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False, study=study
@@ -919,7 +971,7 @@ def test_data_affiliate_component_no_primary_not_in_group(self):
         self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_has_primary_in_group(self):
-        """Data affiliate component agreement, with invalid version, with a valid primary, in CDSA group."""
+        """Member component agreement, with invalid version, with a valid primary, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -934,16 +986,16 @@ def test_data_affiliate_component_invalid_version_has_primary_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_has_primary_not_in_group(self):
-        """Data affiliate component agreement, with invalid version, with a valid primary, not in CDSA group."""
+        """Member component agreement, with invalid version, with a valid primary, not in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -958,18 +1010,18 @@ def test_data_affiliate_component_invalid_version_has_primary_not_in_group(self)
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_has_primary_with_invalid_version_in_group(
         self,
     ):
-        """Data affiliate component agreement, with invalid version, with an invalid primary, in CDSA group."""
+        """Member component agreement, with invalid version, with an invalid primary, in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -984,18 +1036,18 @@ def test_data_affiliate_component_invalid_version_has_primary_with_invalid_versi
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_has_primary_with_invalid_version_not_in_group(
         self,
     ):
-        """Data affiliate component agreement, with invalid version, with an invalid primary, not in CDSA group."""
+        """Member component agreement, with invalid version, with an invalid primary, not in CDSA group."""
         study = StudyFactory.create()
         factories.DataAffiliateAgreementFactory.create(study=study)
         this_agreement = factories.DataAffiliateAgreementFactory.create(
@@ -1010,20 +1062,18 @@ def test_data_affiliate_component_invalid_version_has_primary_with_invalid_versi
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_COMPONENT_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_no_primary_in_group(self):
-        """Data affiliate component agreement, with invalid version, with no primary, in CDSA group."""
-        study = StudyFactory.create()
+        """Member component agreement, with invalid version, with no primary, in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False,
-            study=study,
             signed_agreement__version__major_version__is_valid=False,
         )
         # Add the signed agreement access group to the CDSA group.
@@ -1042,11 +1092,9 @@ def test_data_affiliate_component_invalid_version_no_primary_in_group(self):
         self.assertEqual(record.note, cdsa_audit.NO_PRIMARY_AGREEMENT)
 
     def test_data_affiliate_component_invalid_version_no_primary_not_in_group(self):
-        """Data affiliate component agreement, with invalid version, with no primary, not in CDSA group."""
-        study = StudyFactory.create()
+        """Member component agreement, with invalid version, with no primary, not in CDSA group."""
         this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__is_primary=False,
-            study=study,
             signed_agreement__version__major_version__is_valid=False,
         )
         # # Add the signed agreement access group to the CDSA group.
@@ -1080,7 +1128,7 @@ def test_non_data_affiliate_primary_in_group(self):
         record = cdsa_audit.verified[0]
         self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_non_data_affiliate_primary_not_in_group(self):
         """Non data affiliate primary agreement with valid version not in CDSA group."""
@@ -1098,7 +1146,7 @@ def test_non_data_affiliate_primary_not_in_group(self):
         record = cdsa_audit.needs_action[0]
         self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_non_data_affiliate_primary_invalid_version_in_group(self):
         """Non data affiliate primary agreement with invalid version in CDSA group."""
@@ -1112,13 +1160,13 @@ def test_non_data_affiliate_primary_invalid_version_in_group(self):
         )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, signed_agreement_audit.RemoveAccess)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, signed_agreement_audit.VerifiedAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_non_data_affiliate_primary_invalid_version_not_in_group(self):
         """Non data affiliate primary agreement, with invalid version, not in CDSA group."""
@@ -1132,13 +1180,13 @@ def test_non_data_affiliate_primary_invalid_version_not_in_group(self):
         # )
         cdsa_audit = signed_agreement_audit.SignedAgreementAccessAudit()
         cdsa_audit._audit_signed_agreement(this_agreement.signed_agreement)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, signed_agreement_audit.VerifiedNoAccess)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, signed_agreement_audit.GrantAccess)
         self.assertEqual(record.signed_agreement, this_agreement.signed_agreement)
-        self.assertEqual(record.note, cdsa_audit.INVALID_AGREEMENT_VERSION)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_non_data_affiliate_primary_valid_not_active_in_group(self):
         """Non Data affiliate primary agreement with valid version but isn't active, in CDSA group."""
@@ -1450,7 +1498,7 @@ def test_primary_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_primary_not_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1472,7 +1520,7 @@ def test_primary_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.GrantAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_no_primary_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
@@ -1512,7 +1560,7 @@ def test_no_primary_in_auth_domain(self):
 
     def test_primary_invalid_version_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
-        factories.DataAffiliateAgreementFactory.create(
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__version__major_version__is_valid=False,
             study=workspace.study,
         )
@@ -1523,18 +1571,18 @@ def test_primary_invalid_version_not_in_auth_domain(self):
         # )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
         cdsa_audit._audit_workspace(workspace)
-        self.assertEqual(len(cdsa_audit.verified), 1)
-        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.verified[0]
-        self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
-        self.assertIsNone(record.data_affiliate_agreement)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.GrantAccess)
+        self.assertEqual(record.data_affiliate_agreement, this_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_primary_invalid_version_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
-        factories.DataAffiliateAgreementFactory.create(
+        this_agreement = factories.DataAffiliateAgreementFactory.create(
             signed_agreement__version__major_version__is_valid=False,
             study=workspace.study,
         )
@@ -1545,14 +1593,14 @@ def test_primary_invalid_version_in_auth_domain(self):
         )
         cdsa_audit = workspace_audit.WorkspaceAccessAudit()
         cdsa_audit._audit_workspace(workspace)
-        self.assertEqual(len(cdsa_audit.verified), 0)
-        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
-        record = cdsa_audit.needs_action[0]
-        self.assertIsInstance(record, workspace_audit.RemoveAccess)
-        self.assertIsNone(record.data_affiliate_agreement)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, this_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_primary_inactive_not_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
@@ -1574,7 +1622,7 @@ def test_primary_inactive_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedNoAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_PRIMARY_AGREEMENT)
 
     def test_primary_inactive_in_auth_domain(self):
         workspace = factories.CDSAWorkspaceFactory.create()
@@ -1596,7 +1644,7 @@ def test_primary_inactive_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.RemoveAccess)
         self.assertIsNone(record.data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.INVALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.INACTIVE_PRIMARY_AGREEMENT)
 
     def test_component_agreement_not_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1665,7 +1713,7 @@ def test_two_valid_primary_agreements_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_two_valid_primary_agreements_same_major_version_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1695,7 +1743,7 @@ def test_two_valid_primary_agreements_same_major_version_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_two_valid_primary_agreements_not_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1720,16 +1768,20 @@ def test_two_valid_primary_agreements_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.GrantAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
-    def test_two_primary_one_valid_one_invalid_in_auth_domain(self):
+    def test_two_primary_one_valid_one_invalid_both_active_in_auth_domain(self):
         study = StudyFactory.create()
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=False
+            study=study,
+            signed_agreement__version__major_version__is_valid=True,
+            signed_agreement__version__major_version__version=1,
         )
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=True
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+            signed_agreement__version__major_version__version=2,
         )
         # Add the CDSA group to the auth domain.
         GroupGroupMembershipFactory.create(
@@ -1745,16 +1797,20 @@ def test_two_primary_one_valid_one_invalid_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
-    def test_two_primary_one_valid_one_invalid_not_in_auth_domain(self):
+    def test_two_primary_one_valid_one_invalid_both_active_not_in_auth_domain(self):
         study = StudyFactory.create()
         workspace = factories.CDSAWorkspaceFactory.create(study=study)
         factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=False
+            study=study,
+            signed_agreement__version__major_version__is_valid=True,
+            signed_agreement__version__major_version__version=1,
         )
         data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
-            study=study, signed_agreement__version__major_version__is_valid=True
+            study=study,
+            signed_agreement__version__major_version__is_valid=False,
+            signed_agreement__version__major_version__version=2,
         )
         # Do not add the CDSA group to the auth domain.
         # GroupGroupMembershipFactory.create(
@@ -1770,7 +1826,7 @@ def test_two_primary_one_valid_one_invalid_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.GrantAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_two_primary_one_active_one_inactive_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1797,7 +1853,7 @@ def test_two_primary_one_active_one_inactive_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_two_primary_one_active_one_inactive_not_in_auth_domain(self):
         study = StudyFactory.create()
@@ -1824,7 +1880,65 @@ def test_two_primary_one_active_one_inactive_not_in_auth_domain(self):
         self.assertIsInstance(record, workspace_audit.GrantAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
+
+    def test_two_primary_one_active_invalid_one_inactive_valid_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
+            signed_agreement__version__major_version__is_valid=True,
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # Add the CDSA group to the auth domain.
+        GroupGroupMembershipFactory.create(
+            parent_group=workspace.workspace.authorization_domains.first(),
+            child_group=self.cdsa_group,
+        )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 1)
+        self.assertEqual(len(cdsa_audit.needs_action), 0)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.verified[0]
+        self.assertIsInstance(record, workspace_audit.VerifiedAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
+
+    def test_two_primary_one_active_invalid_one_inactive_valid_not_in_auth_domain(self):
+        study = StudyFactory.create()
+        workspace = factories.CDSAWorkspaceFactory.create(study=study)
+        factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
+            signed_agreement__version__major_version__is_valid=True,
+        )
+        data_affiliate_agreement = factories.DataAffiliateAgreementFactory.create(
+            study=study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+            signed_agreement__version__major_version__is_valid=False,
+        )
+        # # Add the CDSA group to the auth domain.
+        # GroupGroupMembershipFactory.create(
+        #     parent_group=workspace.workspace.authorization_domains.first(),
+        #     child_group=self.cdsa_group,
+        # )
+        cdsa_audit = workspace_audit.WorkspaceAccessAudit()
+        cdsa_audit._audit_workspace(workspace)
+        self.assertEqual(len(cdsa_audit.verified), 0)
+        self.assertEqual(len(cdsa_audit.needs_action), 1)
+        self.assertEqual(len(cdsa_audit.errors), 0)
+        record = cdsa_audit.needs_action[0]
+        self.assertIsInstance(record, workspace_audit.GrantAccess)
+        self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
+        self.assertEqual(record.workspace, workspace)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
 
     def test_no_workspaces(self):
         """Audit works when there are no workspaces."""
@@ -1858,12 +1972,12 @@ def test_two_workspaces(self):
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace_1)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
         record = cdsa_audit.verified[1]
         self.assertIsInstance(record, workspace_audit.VerifiedAccess)
         self.assertEqual(record.data_affiliate_agreement, data_affiliate_agreement)
         self.assertEqual(record.workspace, workspace_2)
-        self.assertEqual(record.note, cdsa_audit.VALID_PRIMARY_AGREEMENT)
+        self.assertEqual(record.note, cdsa_audit.ACTIVE_PRIMARY_AGREEMENT)
         self.assertEqual(len(cdsa_audit.needs_action), 0)
         self.assertEqual(len(cdsa_audit.errors), 0)
 
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index b6d35f2a..401e7456 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -4387,14 +4387,14 @@ def test_context_verified_table_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_AGREEMENT,
+            signed_agreement_audit.SignedAgreementAccessAudit.ACTIVE_PRIMARY_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
     def test_context_verified_table_no_access(self):
         """verified_table shows a record when audit has verified no access."""
         member_agreement = factories.MemberAgreementFactory.create(
-            signed_agreement__version__major_version__is_valid=False
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
         )
         # Check the table in the context.
         self.client.force_login(self.user)
@@ -4412,7 +4412,7 @@ def test_context_verified_table_no_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.INVALID_AGREEMENT_VERSION,
+            signed_agreement_audit.SignedAgreementAccessAudit.INACTIVE_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
@@ -4435,7 +4435,7 @@ def test_context_needs_action_table_grant(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            signed_agreement_audit.SignedAgreementAccessAudit.VALID_PRIMARY_AGREEMENT,
+            signed_agreement_audit.SignedAgreementAccessAudit.ACTIVE_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 
@@ -4571,7 +4571,7 @@ def test_context_verified_table_access(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_AGREEMENT,
+            workspace_audit.WorkspaceAccessAudit.ACTIVE_PRIMARY_AGREEMENT,
         )
         self.assertIsNone(table.rows[0].get_cell_value("action"))
 
@@ -4624,7 +4624,7 @@ def test_context_needs_action_table_grant(self):
         )
         self.assertEqual(
             table.rows[0].get_cell_value("note"),
-            workspace_audit.WorkspaceAccessAudit.VALID_PRIMARY_AGREEMENT,
+            workspace_audit.WorkspaceAccessAudit.ACTIVE_PRIMARY_AGREEMENT,
         )
         self.assertIsNotNone(table.rows[0].get_cell_value("action"))
 

From c3fbfcfe548b5cd8688655dd9f5ecf346e50470f Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 22 Sep 2023 14:00:56 -0700
Subject: [PATCH 46/53] Add a view to invalidate major agreement versions

This view invalidates a given AgreementMajorVerison instance and
also sets the status of all associated agreements to Lapsed.
---
 primed/cdsa/forms.py                          |   9 +
 primed/cdsa/tests/test_views.py               | 219 ++++++++++++++++++
 primed/cdsa/urls.py                           |   5 +
 primed/cdsa/views.py                          |  62 +++++
 ...eementmajorversion_confirm_invalidate.html |  31 +++
 5 files changed, 326 insertions(+)
 create mode 100644 primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html

diff --git a/primed/cdsa/forms.py b/primed/cdsa/forms.py
index 2e0c1ec2..678991df 100644
--- a/primed/cdsa/forms.py
+++ b/primed/cdsa/forms.py
@@ -10,6 +10,15 @@
 from . import models
 
 
+class AgreementMajorVersionIsValidForm(forms.ModelForm):
+    class Meta:
+        model = models.AgreementMajorVersion
+        fields = ("is_valid",)
+        widgets = {
+            "is_valid": forms.HiddenInput,
+        }
+
+
 class SignedAgreementForm(Bootstrap5MediaFormMixin, forms.ModelForm):
     """Form for a SignedAgreement object."""
 
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 401e7456..cc9a8ac8 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -255,6 +255,225 @@ def test_response_show_deprecation_message_not_valid(self):
         self.assertIn(b"Deprecated", response.content)
 
 
+class AgreementMajorVersionInvalidateTest(TestCase):
+    """Tests for the AgreementMajorVersionInvalidate view."""
+
+    def setUp(self):
+        """Set up test class."""
+        super().setUp()
+        self.factory = RequestFactory()
+        # Create a user with both view and edit permission.
+        self.user = User.objects.create_user(username="test", password="test")
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        self.user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+
+    def get_url(self, *args):
+        """Get the url for the view being tested."""
+        return reverse("cdsa:agreement_versions:invalidate", args=args)
+
+    def get_view(self):
+        """Return the view being tested."""
+        return views.AgreementMajorVersionInvalidate.as_view()
+
+    def test_view_redirect_not_logged_in(self):
+        "View redirects to login view when user is not logged in."
+        # Need a client for redirects.
+        response = self.client.get(self.get_url(1))
+        self.assertRedirects(
+            response, resolve_url(settings.LOGIN_URL) + "?next=" + self.get_url(1)
+        )
+
+    def test_status_code_with_user_permission_edit(self):
+        """Returns successful response code."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version))
+        self.assertEqual(response.status_code, 200)
+
+    def test_access_without_user_permission(self):
+        """Raises permission denied if user has no permissions."""
+        user_no_perms = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        request = self.factory.get(self.get_url(1))
+        request.user = user_no_perms
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, major_version=1)
+
+    def test_access_without_user_permission_view(self):
+        """Raises permission denied if user has only view permission."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        user_view_perm = User.objects.create_user(
+            username="test-none", password="test-none"
+        )
+        user_view_perm.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        request = self.factory.get(self.get_url(instance.version))
+        request.user = user_view_perm
+        with self.assertRaises(PermissionDenied):
+            self.get_view()(request, major_version=instance.version)
+
+    def test_object_does_not_exist(self):
+        request = self.factory.get(self.get_url(1))
+        request.user = self.user
+        with self.assertRaises(Http404):
+            self.get_view()(request, major_version=1)
+
+    def test_has_object_in_context(self):
+        """Response includes a form."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version))
+        self.assertTrue("object" in response.context_data)
+        self.assertEqual(response.context_data["object"], instance)
+
+    def test_has_form_in_context(self):
+        """Response includes a form."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version))
+        self.assertTrue("form" in response.context_data)
+
+    def test_form_class(self):
+        """Form is the expected class."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version))
+        self.assertIsInstance(
+            response.context_data["form"], forms.AgreementMajorVersionIsValidForm
+        )
+
+    def test_invalidates_instance(self):
+        """Can invalidate the instance."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertEqual(response.status_code, 302)
+        instance.refresh_from_db()
+        self.assertFalse(instance.is_valid)
+
+    def test_sets_one_signed_agreement_to_lapsed(self):
+        """Sets SignedAgreements associated with this major version to LAPSED."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        signed_agreement = factories.SignedAgreementFactory.create(
+            version__major_version=instance
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertEqual(response.status_code, 302)
+        signed_agreement.refresh_from_db()
+        self.assertEqual(
+            signed_agreement.status, models.SignedAgreement.StatusChoices.LAPSED
+        )
+
+    def test_sets_two_signed_agreements_to_lapsed(self):
+        """Sets SignedAgreements associated with this major version to LAPSED."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        signed_agreement_1 = factories.SignedAgreementFactory.create(
+            version__major_version=instance
+        )
+        signed_agreement_2 = factories.SignedAgreementFactory.create(
+            version__major_version=instance
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertEqual(response.status_code, 302)
+        signed_agreement_1.refresh_from_db()
+        self.assertEqual(
+            signed_agreement_1.status, models.SignedAgreement.StatusChoices.LAPSED
+        )
+        signed_agreement_2.refresh_from_db()
+        self.assertEqual(
+            signed_agreement_2.status, models.SignedAgreement.StatusChoices.LAPSED
+        )
+
+    def test_only_sets_active_signed_agreements_to_lapsed(self):
+        """Does not set SignedAgreements with a different status to LAPSED."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        withdrawn_agreement = factories.SignedAgreementFactory.create(
+            version__major_version=instance,
+            status=models.SignedAgreement.StatusChoices.WITHDRAWN,
+        )
+        lapsed_agreement = factories.SignedAgreementFactory.create(
+            version__major_version=instance,
+            status=models.SignedAgreement.StatusChoices.LAPSED,
+        )
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertEqual(response.status_code, 302)
+        lapsed_agreement.refresh_from_db()
+        self.assertEqual(
+            lapsed_agreement.status, models.SignedAgreement.StatusChoices.LAPSED
+        )
+        withdrawn_agreement.refresh_from_db()
+        self.assertEqual(
+            withdrawn_agreement.status, models.SignedAgreement.StatusChoices.WITHDRAWN
+        )
+
+    def test_only_sets_associated_signed_agreements_to_lapsed(self):
+        """Does not set SignedAgreements associated with a different version to LAPSED."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        signed_agreement = factories.SignedAgreementFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertEqual(response.status_code, 302)
+        signed_agreement.refresh_from_db()
+        self.assertEqual(
+            signed_agreement.status, models.SignedAgreement.StatusChoices.ACTIVE
+        )
+
+    def test_redirect_url(self):
+        """Redirects to successful url."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        self.assertRedirects(response, instance.get_absolute_url())
+
+    def test_success_message(self):
+        """Redirects to successful url."""
+        instance = factories.AgreementMajorVersionFactory.create()
+        self.client.force_login(self.user)
+        response = self.client.post(self.get_url(instance.version), {})
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.AgreementMajorVersionInvalidate.success_message, str(messages[0])
+        )
+
+    def test_version_already_invalid_get(self):
+        instance = factories.AgreementMajorVersionFactory.create(is_valid=False)
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version))
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.AgreementMajorVersionInvalidate.ERROR_ALREADY_INVALID,
+            str(messages[0]),
+        )
+
+    def test_version_already_invalid_post(self):
+        instance = factories.AgreementMajorVersionFactory.create(is_valid=False)
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(instance.version), {})
+        messages = [m.message for m in get_messages(response.wsgi_request)]
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(
+            views.AgreementMajorVersionInvalidate.ERROR_ALREADY_INVALID,
+            str(messages[0]),
+        )
+
+
 class AgreementVersionDetailTest(TestCase):
     """Tests for the AgreementVersionDetail view."""
 
diff --git a/primed/cdsa/urls.py b/primed/cdsa/urls.py
index b35c4ef5..742fffd5 100644
--- a/primed/cdsa/urls.py
+++ b/primed/cdsa/urls.py
@@ -16,6 +16,11 @@
             views.AgreementMajorVersionDetail.as_view(),
             name="major_version_detail",
         ),
+        path(
+            "v<int:major_version>/invalidate/",
+            views.AgreementMajorVersionInvalidate.as_view(),
+            name="invalidate",
+        ),
         path(
             "v<int:major_version>.<int:minor_version>/",
             views.AgreementVersionDetail.as_view(),
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 1e78d57e..07a3392a 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -60,6 +60,68 @@ def get_context_data(self, **kwargs):
         return context
 
 
+class AgreementMajorVersionInvalidate(
+    AnVILConsortiumManagerEditRequired, SuccessMessageMixin, UpdateView
+):
+    """A view to invalidate an AgreementMajorVersion instance.
+
+    This view sets the is_valid field to False. It also sets the status of all associated
+    CDSAs to LAPSED.
+    """
+
+    # Note that this view mimics the DeleteView.
+    model = models.AgreementMajorVersion
+    # form_class = Form
+    form_class = forms.AgreementMajorVersionIsValidForm
+    template_name = "cdsa/agreementmajorversion_confirm_invalidate.html"
+    success_message = "Successfully invalidated major agreement version."
+    ERROR_ALREADY_INVALID = "This version has already been invalidated."
+
+    def get_object(self, queryset=None):
+        queryset = self.model.objects.all()
+        try:
+            major_version = self.kwargs["major_version"]
+            obj = queryset.get(version=major_version)
+        except (KeyError, self.model.DoesNotExist):
+            raise Http404(
+                _("No %(verbose_name)s found matching the query")
+                % {"verbose_name": queryset.model._meta.verbose_name}
+            )
+        return obj
+
+    def get_initial(self):
+        """Set is_valid to False, since this view is invalidating a specific AgreementMajorVersion."""
+        initial = super().get_initial()
+        initial["is_valid"] = False
+        return initial
+
+    def get(self, response, *args, **kwargs):
+        self.object = self.get_object()
+        if not self.object.is_valid:
+            messages.error(self.request, self.ERROR_ALREADY_INVALID)
+            return HttpResponseRedirect(self.object.get_absolute_url())
+        return super().get(response, *args, **kwargs)
+
+    def post(self, response, *args, **kwargs):
+        self.object = self.get_object()
+        if not self.object.is_valid:
+            messages.error(self.request, self.ERROR_ALREADY_INVALID)
+            return HttpResponseRedirect(self.object.get_absolute_url())
+        return super().post(response, *args, **kwargs)
+
+    def form_valid(self, form):
+        models.SignedAgreement.objects.filter(
+            status=models.SignedAgreement.StatusChoices.ACTIVE,
+            version__major_version=self.object,
+        ).update(status=models.SignedAgreement.StatusChoices.LAPSED)
+        return super().form_valid(form)
+
+    def get_success_url(self):
+        return self.object.get_absolute_url()
+
+    # Change status for CDSAs to lapsed when their major version is invalidated.
+
+
 class AgreementVersionDetail(
     AnVILConsortiumManagerViewRequired, SingleTableMixin, DetailView
 ):
diff --git a/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html b/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html
new file mode 100644
index 00000000..0074fe95
--- /dev/null
+++ b/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html
@@ -0,0 +1,31 @@
+{% extends "anvil_consortium_manager/base.html" %}
+{% load static %}
+
+{% block title %}Remove Group Account Membership{% endblock %}
+
+{% block content %}
+<div class="container">
+
+  <div class="row">
+    <div class="col-sm-12">
+
+
+      <h2>Invalidate Agreement {{ object }}</h2>
+
+      <p>Are you sure you want to invalidate Agreement <a href="{{ objectget_absolute_url }}">{{ object }}</a>?</p>
+
+      <p>This will change the status of all "Active" agreementes associated with this version to "Lapsed". </p>
+
+      <form method="POST">{% csrf_token %}
+          {{ form }}
+          <input type="submit" class="btn btn-danger" value="Yes, invalidate"/>
+          <a href="{{ object.get_absolute_url }}" class="btn btn-secondary" role="button">
+          No, cancel</a>
+      </form>
+
+    </div>
+  </div>
+
+
+</div>
+{% endblock content %}

From 5917a0e105709c9325eb311d63bcb3eabb277305 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 22 Sep 2023 14:46:52 -0700
Subject: [PATCH 47/53] Add an invalidate button to the AgreementMajorVersion
 detail template

This button is only shown if the user has edit permission and the
version is valid.
---
 primed/cdsa/tests/test_views.py               | 74 +++++++++++++++++++
 primed/cdsa/views.py                          |  9 +++
 .../cdsa/agreementmajorversion_detail.html    |  8 ++
 3 files changed, 91 insertions(+)

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index cc9a8ac8..3c48cc47 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -254,6 +254,80 @@ def test_response_show_deprecation_message_not_valid(self):
         self.assertTrue(response.context_data["show_deprecation_message"])
         self.assertIn(b"Deprecated", response.content)
 
+    def test_invalidate_button_valid_user_has_edit_perm(self):
+        """Invalidate button appears when the user has edit permission and the instance is valid."""
+        user = User.objects.create_user(username="test_edit", password="test_edit")
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+        self.client.force_login(user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_invalidate_button", response.context_data)
+        self.assertTrue(response.context_data["show_invalidate_button"])
+        self.assertContains(
+            response,
+            reverse("cdsa:agreement_versions:invalidate", args=[self.obj.version]),
+        )
+
+    def test_invalidate_button_valid_user_has_view_perm(self):
+        """Invalidate button does not appear when the user has view permission and the instance is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_invalidate_button", response.context_data)
+        self.assertFalse(response.context_data["show_invalidate_button"])
+        self.assertNotContains(
+            response,
+            reverse("cdsa:agreement_versions:invalidate", args=[self.obj.version]),
+        )
+
+    def test_invalidate_button_invalid_user_has_edit_perm(self):
+        """Invalidate button does not appear when the user has edit permission and the instance is invalid."""
+        self.obj.is_valid = False
+        self.obj.save()
+        user = User.objects.create_user(username="test_edit", password="test_edit")
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+        self.client.force_login(user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_invalidate_button", response.context_data)
+        self.assertFalse(response.context_data["show_invalidate_button"])
+        self.assertNotContains(
+            response,
+            reverse("cdsa:agreement_versions:invalidate", args=[self.obj.version]),
+        )
+
+    def test_invalidate_button_invalid_user_has_view_perm(self):
+        """Invalidate button does not appear when the user has view permission and the instance is invalid."""
+        self.obj.is_valid = False
+        self.obj.save()
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.version))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_invalidate_button", response.context_data)
+        self.assertFalse(response.context_data["show_invalidate_button"])
+        self.assertNotContains(
+            response,
+            reverse("cdsa:agreement_versions:invalidate", args=[self.obj.version]),
+        )
+
 
 class AgreementMajorVersionInvalidateTest(TestCase):
     """Tests for the AgreementMajorVersionInvalidate view."""
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 07a3392a..666f6a5d 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -4,6 +4,7 @@
 from anvil_consortium_manager.auth import (
     AnVILConsortiumManagerEditRequired,
     AnVILConsortiumManagerViewRequired,
+    AnVILProjectManagerAccess,
 )
 from anvil_consortium_manager.models import GroupAccountMembership, ManagedGroup
 from django.conf import settings
@@ -57,6 +58,14 @@ def get_tables_data(self):
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         context["show_deprecation_message"] = not self.object.is_valid
+        edit_permission_codename = "anvil_consortium_manager." + (
+            AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+        )
+        context[
+            "show_invalidate_button"
+        ] = self.object.is_valid and self.request.user.has_perm(
+            edit_permission_codename
+        )
         return context
 
 
diff --git a/primed/templates/cdsa/agreementmajorversion_detail.html b/primed/templates/cdsa/agreementmajorversion_detail.html
index b4ea6bef..f9199b33 100644
--- a/primed/templates/cdsa/agreementmajorversion_detail.html
+++ b/primed/templates/cdsa/agreementmajorversion_detail.html
@@ -62,3 +62,11 @@ <h2 class="accordion-header" id="signed-agreements-heading">
 </div>
 
 {% endblock after_panel %}
+
+
+{% block action_buttons %}
+  {% if show_invalidate_button %}
+  <a href="{% url 'cdsa:agreement_versions:invalidate' major_version=object.version %}" class="btn btn-danger" role="button">Invalidate this version</a>
+  </p>
+  {% endif %}
+{% endblock action_buttons %}

From 5e16d6a26101053e8006172247df05279ad5477c Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 22 Sep 2023 15:35:06 -0700
Subject: [PATCH 48/53] Update CDSA records tables to only show active records

Only records associated with an active SignedAgreement are shown
in the tables.
---
 primed/cdsa/helpers.py             | 19 ++++--
 primed/cdsa/tests/test_commands.py |  3 +-
 primed/cdsa/tests/test_views.py    | 94 +++++++++++++++++++++++++++++-
 3 files changed, 108 insertions(+), 8 deletions(-)

diff --git a/primed/cdsa/helpers.py b/primed/cdsa/helpers.py
index 945185fc..5f613969 100644
--- a/primed/cdsa/helpers.py
+++ b/primed/cdsa/helpers.py
@@ -5,23 +5,34 @@
 
 def get_representative_records_table():
     """Return the queryset for representative records."""
-    qs = models.SignedAgreement.objects.all()
+    qs = models.SignedAgreement.active.all()
     return tables.RepresentativeRecordsTable(qs)
 
 
 def get_study_records_table():
     """Return the queryset for study records."""
-    qs = models.DataAffiliateAgreement.objects.filter(signed_agreement__is_primary=True)
+    qs = models.DataAffiliateAgreement.objects.filter(
+        signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+        signed_agreement__is_primary=True,
+    )
     return tables.StudyRecordsTable(qs)
 
 
 def get_user_access_records_table():
     """Return the queryset for user access records."""
-    qs = GroupAccountMembership.objects.filter(group__signedagreement__isnull=False)
+    qs = GroupAccountMembership.objects.filter(
+        group__signedagreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+        group__signedagreement__isnull=False,
+    )
     return tables.UserAccessRecordsTable(qs)
 
 
 def get_cdsa_workspace_records_table():
     """Return the queryset for workspace records."""
-    qs = models.CDSAWorkspace.objects.all()
+    active_data_affiliates = models.DataAffiliateAgreement.objects.filter(
+        signed_agreement__status=models.SignedAgreement.StatusChoices.ACTIVE,
+    )
+    qs = models.CDSAWorkspace.objects.filter(
+        study__dataaffiliateagreement__in=active_data_affiliates,
+    )
     return tables.CDSAWorkspaceRecordsTable(qs)
diff --git a/primed/cdsa/tests/test_commands.py b/primed/cdsa/tests/test_commands.py
index b8ac8c76..e5ad8ebe 100644
--- a/primed/cdsa/tests/test_commands.py
+++ b/primed/cdsa/tests/test_commands.py
@@ -74,7 +74,8 @@ def test_cdsa_workspace_records_zero(self):
         self.assertEqual(len(lines), 1)
 
     def test_cdsa_workspace_records_one(self):
-        factories.CDSAWorkspaceFactory.create()
+        agreement = factories.DataAffiliateAgreementFactory.create()
+        factories.CDSAWorkspaceFactory.create(study=agreement.study)
         out = StringIO()
         call_command("cdsa_records", self.outdir, "--no-color", stdout=out)
         with open(os.path.join(self.outdir, "workspace_records.tsv")) as f:
diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 3c48cc47..78f0a446 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -4593,6 +4593,23 @@ def test_table_three_rows(self):
         self.assertIn("table", response.context_data)
         self.assertEqual(len(response.context_data["table"].rows), 3)
 
+    def test_only_includes_active_agreements(self):
+        active_agreement = factories.MemberAgreementFactory.create()
+        lapsed_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.LAPSED
+        )
+        withdrawn_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        table = response.context_data["table"]
+        self.assertEqual(len(table.rows), 1)
+        self.assertIn(active_agreement.signed_agreement, table.data)
+        self.assertNotIn(lapsed_agreement.signed_agreement, table.data)
+        self.assertNotIn(withdrawn_agreement.signed_agreement, table.data)
+
 
 class SignedAgreementAuditTest(TestCase):
     """Tests for the SignedAgreementAudit view."""
@@ -5041,6 +5058,23 @@ def test_only_shows_primary_data_affiliate_records(self):
         self.assertIn(primary_agreement, table.data)
         self.assertNotIn(component_agreement, table.data)
 
+    def test_only_includes_active_agreements(self):
+        active_agreement = factories.DataAffiliateAgreementFactory.create()
+        lapsed_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.LAPSED
+        )
+        withdrawn_agreement = factories.DataAffiliateAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        table = response.context_data["table"]
+        self.assertEqual(len(table.rows), 1)
+        self.assertIn(active_agreement, table.data)
+        self.assertNotIn(lapsed_agreement, table.data)
+        self.assertNotIn(withdrawn_agreement, table.data)
+
 
 class UserAccessRecordsList(TestCase):
     """Tests for the StudyRecordsList view."""
@@ -5200,6 +5234,32 @@ def test_does_not_show_other_group_members(self):
         table = response.context_data["table"]
         self.assertEqual(len(table.rows), 0)
 
+    def test_only_includes_active_agreements(self):
+        active_agreement = factories.MemberAgreementFactory.create()
+        active_member = GroupAccountMembershipFactory.create(
+            group=active_agreement.signed_agreement.anvil_access_group
+        )
+        lapsed_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.LAPSED
+        )
+        lapsed_member = GroupAccountMembershipFactory.create(
+            group=lapsed_agreement.signed_agreement.anvil_access_group
+        )
+        withdrawn_agreement = factories.MemberAgreementFactory.create(
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN
+        )
+        withdrawn_member = GroupAccountMembershipFactory.create(
+            group=withdrawn_agreement.signed_agreement.anvil_access_group
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        table = response.context_data["table"]
+        self.assertEqual(len(table.rows), 1)
+        self.assertIn(active_member, table.data)
+        self.assertNotIn(lapsed_member, table.data)
+        self.assertNotIn(withdrawn_member, table.data)
+
 
 class CDSAWorkspaceRecordsList(TestCase):
     """Tests for the CDSAWorkspaceRecords view."""
@@ -5242,13 +5302,41 @@ def test_table_no_rows(self):
         self.assertIn("table", response.context_data)
         self.assertEqual(len(response.context_data["table"].rows), 0)
 
-    def test_table_three_rows(self):
+    def test_table_two_rows(self):
         """Three rows are shown if there are three CDSAWorkspaces objects."""
-        factories.CDSAWorkspaceFactory.create_batch(3)
+        active_workspace_1 = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=active_workspace_1.study)
+        active_workspace_2 = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=active_workspace_2.study)
         self.client.force_login(self.user)
         response = self.client.get(self.get_url())
         self.assertIn("table", response.context_data)
-        self.assertEqual(len(response.context_data["table"].rows), 3)
+        table = response.context_data["table"]
+        self.assertEqual(len(table.rows), 2)
+        self.assertIn(active_workspace_1, table.data)
+        self.assertIn(active_workspace_2, table.data)
+
+    def test_only_includes_workspaces_with_active_agreements(self):
+        active_workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(study=active_workspace.study)
+        lapsed_workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=lapsed_workspace.study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.LAPSED,
+        )
+        withdrawn_workspace = factories.CDSAWorkspaceFactory.create()
+        factories.DataAffiliateAgreementFactory.create(
+            study=withdrawn_workspace.study,
+            signed_agreement__status=models.SignedAgreement.StatusChoices.WITHDRAWN,
+        )
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url())
+        self.assertIn("table", response.context_data)
+        table = response.context_data["table"]
+        self.assertEqual(len(table.rows), 1)
+        self.assertIn(active_workspace, table.data)
+        self.assertNotIn(lapsed_workspace, table.data)
+        self.assertNotIn(withdrawn_workspace, table.data)
 
 
 class CDSAWorkspaceDetailTest(TestCase):

From 1a2d5fe421924b4b1da8abd28599dc96d60f645e Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 22 Sep 2023 16:03:38 -0700
Subject: [PATCH 49/53] Update audit templates for SignedAgreement status info

---
 primed/templates/cdsa/cdsaworkspace_audit.html   |  9 +++++----
 primed/templates/cdsa/signedagreement_audit.html | 11 +++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/primed/templates/cdsa/cdsaworkspace_audit.html b/primed/templates/cdsa/cdsaworkspace_audit.html
index 9f0b1fe7..c4a92fd7 100644
--- a/primed/templates/cdsa/cdsaworkspace_audit.html
+++ b/primed/templates/cdsa/cdsaworkspace_audit.html
@@ -22,17 +22,18 @@ <h2>Audit results</h2>
 
       <li><b>Verified</b> includes the following:</li>
         <ul>
-          <li>CDSA workspaces that have a valid, primary Signed Agreement from the same study, and the PRIMED CDSA group is in the auth domain of the workspace.</li>
-          <li>CDSA workspaces that do not have a valid, primary Signed Agreement from the same study, and the PRIMED CDSA group is <b>not</b> in the auth domain of the workspace.</li>
+          <li>CDSA workspaces with an active primary Data Affiliate Agreement, and the PRIMED CDSA group <b>is</b> in the auth domain of the workspace.</li>
+          <li>CDSA workspaces without an active primary Data Affiliate Agreement, and the PRIMED CDSA group <b>is not</b> in the auth domain of the workspace.</li>
         </ul>
       <li><b>Needs action</b> includes the following:</li>
       <ul>
-        <li>CDSA workspaces that have an associated valid, primary Signed Agreement for the same study, but the PRIMED CDSA group is not in the auth domain of the workspace.</li>
+        <li>CDSA workspaces with an active primary Data Affiliate Agreement, but the PRIMED CDSA group <b>is not</b> in the auth domain of the workspace.</li>
+        <li>CDSA workspaces with an inactive primary Data Affiliate Agreement, and the PRIMED CDSA group <b>is</b> in the auth domain of the workspace.</li>
       </ul>
 
       <li><b>Errors</b></li>
       <ul>
-        <li>The PRIMED CDSA group is in the auth domain of the workspace, but there is no associated valid, primary Signed Agreement for the study.</li>
+        <li>The PRIMED CDSA group is in the auth domain of the workspace, but there is no primary Signed Agreement from the study.</li>
       </ul>
     </ul>
   </p>
diff --git a/primed/templates/cdsa/signedagreement_audit.html b/primed/templates/cdsa/signedagreement_audit.html
index 0e5751f7..cbe7f914 100644
--- a/primed/templates/cdsa/signedagreement_audit.html
+++ b/primed/templates/cdsa/signedagreement_audit.html
@@ -20,14 +20,17 @@ <h2>Audit results</h2>
 
       <li><b>Verified</b> includes the following:</li>
         <ul>
-          <li>Primary Signed Agreements that are in the PRIMED CDSA group on AnVIL.</li>
-          <li>Component Signed Agreements with a primary that are in the PRIMED CDSA group on AnVIL.</li>
-          <li>Component Signed Agreements without a primary that are <b>not</b> in the PRIMED CDSA group on AnVIL.</li>
+          <li>Active primary Signed Agreements that are in the PRIMED CDSA group on AnVIL.</li>
+          <li>Active component Signed Agreements with an active primary that are in the PRIMED CDSA group on AnVIL.</li>
+          <li>Active component Signed Agreements without an active primary that are <b>not</b> in the PRIMED CDSA group on AnVIL.</li>
+          <li>Inctive primary Signed Agreements that are <b>not</b> in the PRIMED CDSA group on AnVIL.</li>
+          <li>Inctive component Signed Agreements that are <b>not</b> in the PRIMED CDSA group on AnVIL.</li>
         </ul>
 
       <li><b>Needs action</b> includes the following:</li>
       <ul>
-        <li>Valid Signed Agreements that are not in the PRIMED CDSA group on AnVIL.</li>
+        <li>Active primary Signed Agreements that are not in the PRIMED CDSA group on AnVIL.</li>
+        <li>Active component Signed Agreements with an active primary that are not in the PRIMED CDSA group on AnVIL.</li>
       </ul>
 
       <li><b>Errors</b></li>

From 662efcbb91e2631e70cb54475d7e79aa2e85233c Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 22 Sep 2023 16:23:28 -0700
Subject: [PATCH 50/53] Show button to change status on SignedAgreement detail
 pages

---
 primed/cdsa/tests/test_views.py               | 123 ++++++++++++++++++
 primed/cdsa/views.py                          |  18 +++
 .../cdsa/dataaffiliateagreement_detail.html   |   8 ++
 .../cdsa/memberagreement_detail.html          |   8 ++
 .../nondataaffiliateagreement_detail.html     |   8 ++
 .../templates/cdsa/signedagreement_form.html  |   1 -
 .../cdsa/signedagreement_status_update.html   |   2 +-
 7 files changed, 166 insertions(+), 2 deletions(-)

diff --git a/primed/cdsa/tests/test_views.py b/primed/cdsa/tests/test_views.py
index 78f0a446..1689582b 100644
--- a/primed/cdsa/tests/test_views.py
+++ b/primed/cdsa/tests/test_views.py
@@ -2253,6 +2253,47 @@ def test_response_show_deprecation_message_not_valid(self):
         self.assertTrue(response.context_data["show_deprecation_message"])
         self.assertIn(b"Deprecated CDSA version", response.content)
 
+    def test_change_status_button_user_has_edit_perm(self):
+        """Invalidate button appears when the user has edit permission and the instance is valid."""
+        user = User.objects.create_user(username="test_edit", password="test_edit")
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+        self.client.force_login(user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertTrue(response.context_data["show_update_button"])
+        self.assertContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:members:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
+    def test_change_status_button_user_has_view_perm(self):
+        """Invalidate button does not appear when the user has view permission and the instance is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertFalse(response.context_data["show_update_button"])
+        self.assertNotContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:members:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
 
 class MemberAgreementListTest(TestCase):
     """Tests for the MemberAgreementList view."""
@@ -3430,6 +3471,47 @@ def test_response_show_deprecation_message_not_valid(self):
         self.assertTrue(response.context_data["show_deprecation_message"])
         self.assertIn(b"Deprecated CDSA version", response.content)
 
+    def test_change_status_button_user_has_edit_perm(self):
+        """Invalidate button appears when the user has edit permission and the instance is valid."""
+        user = User.objects.create_user(username="test_edit", password="test_edit")
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+        self.client.force_login(user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertTrue(response.context_data["show_update_button"])
+        self.assertContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:data_affiliates:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
+    def test_change_status_button_user_has_view_perm(self):
+        """Invalidate button does not appear when the user has view permission and the instance is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertFalse(response.context_data["show_update_button"])
+        self.assertNotContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:data_affiliates:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
 
 class DataAffiliateAgreementListTest(TestCase):
     """Tests for the DataAffiliateAgreement view."""
@@ -4434,6 +4516,47 @@ def test_response_show_deprecation_message_is_not_valid(self):
         self.assertTrue(response.context_data["show_deprecation_message"])
         self.assertIn(b"Deprecated CDSA version", response.content)
 
+    def test_change_status_button_user_has_edit_perm(self):
+        """Invalidate button appears when the user has edit permission and the instance is valid."""
+        user = User.objects.create_user(username="test_edit", password="test_edit")
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.VIEW_PERMISSION_CODENAME
+            )
+        )
+        user.user_permissions.add(
+            Permission.objects.get(
+                codename=AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+            )
+        )
+        self.client.force_login(user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertTrue(response.context_data["show_update_button"])
+        self.assertContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:non_data_affiliates:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
+    def test_change_status_button_user_has_view_perm(self):
+        """Invalidate button does not appear when the user has view permission and the instance is valid."""
+        self.client.force_login(self.user)
+        response = self.client.get(self.get_url(self.obj.signed_agreement.cc_id))
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("show_update_button", response.context_data)
+        self.assertFalse(response.context_data["show_update_button"])
+        self.assertNotContains(
+            response,
+            reverse(
+                "cdsa:signed_agreements:non_data_affiliates:update",
+                args=[self.obj.signed_agreement.cc_id],
+            ),
+        )
+
 
 class NonDataAffiliateAgreementListTest(TestCase):
     """Tests for the NonDataAffiliateAgreement view."""
diff --git a/primed/cdsa/views.py b/primed/cdsa/views.py
index 666f6a5d..df0c4f8b 100644
--- a/primed/cdsa/views.py
+++ b/primed/cdsa/views.py
@@ -370,6 +370,12 @@ def get_context_data(self, **kwargs):
         context[
             "show_deprecation_message"
         ] = not self.object.signed_agreement.version.major_version.is_valid
+        edit_permission_codename = "anvil_consortium_manager." + (
+            AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+        )
+        context["show_update_button"] = self.request.user.has_perm(
+            edit_permission_codename
+        )
         return context
 
 
@@ -427,6 +433,12 @@ def get_context_data(self, **kwargs):
         context[
             "show_deprecation_message"
         ] = not self.object.signed_agreement.version.major_version.is_valid
+        edit_permission_codename = "anvil_consortium_manager." + (
+            AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+        )
+        context["show_update_button"] = self.request.user.has_perm(
+            edit_permission_codename
+        )
         return context
 
 
@@ -476,6 +488,12 @@ def get_context_data(self, **kwargs):
         context[
             "show_deprecation_message"
         ] = not self.object.signed_agreement.version.major_version.is_valid
+        edit_permission_codename = "anvil_consortium_manager." + (
+            AnVILProjectManagerAccess.EDIT_PERMISSION_CODENAME
+        )
+        context["show_update_button"] = self.request.user.has_perm(
+            edit_permission_codename
+        )
         return context
 
 
diff --git a/primed/templates/cdsa/dataaffiliateagreement_detail.html b/primed/templates/cdsa/dataaffiliateagreement_detail.html
index 078c82d0..211b3e92 100644
--- a/primed/templates/cdsa/dataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/dataaffiliateagreement_detail.html
@@ -44,3 +44,11 @@
 
 </dl>
 {% endblock panel %}
+
+
+{% block action_buttons %}
+  {% if show_update_button %}
+  <a href="{% url 'cdsa:signed_agreements:data_affiliates:update' cc_id=object.signed_agreement.cc_id %}" class="btn btn-primary" role="button">Update status</a>
+  </p>
+  {% endif %}
+{% endblock action_buttons %}
diff --git a/primed/templates/cdsa/memberagreement_detail.html b/primed/templates/cdsa/memberagreement_detail.html
index eafdde26..381b1f23 100644
--- a/primed/templates/cdsa/memberagreement_detail.html
+++ b/primed/templates/cdsa/memberagreement_detail.html
@@ -40,3 +40,11 @@
 
 </dl>
 {% endblock panel %}
+
+
+{% block action_buttons %}
+  {% if show_update_button %}
+  <a href="{% url 'cdsa:signed_agreements:members:update' cc_id=object.signed_agreement.cc_id %}" class="btn btn-primary" role="button">Update status</a>
+  </p>
+  {% endif %}
+{% endblock action_buttons %}
diff --git a/primed/templates/cdsa/nondataaffiliateagreement_detail.html b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
index e0c5df9c..bcd4b934 100644
--- a/primed/templates/cdsa/nondataaffiliateagreement_detail.html
+++ b/primed/templates/cdsa/nondataaffiliateagreement_detail.html
@@ -39,3 +39,11 @@
 
 </dl>
 {% endblock panel %}
+
+
+{% block action_buttons %}
+  {% if show_update_button %}
+  <a href="{% url 'cdsa:signed_agreements:non_data_affiliates:update' cc_id=object.signed_agreement.cc_id %}" class="btn btn-primary" role="button">Update status</a>
+  </p>
+  {% endif %}
+{% endblock action_buttons %}
diff --git a/primed/templates/cdsa/signedagreement_form.html b/primed/templates/cdsa/signedagreement_form.html
index 485d6665..49dc1270 100644
--- a/primed/templates/cdsa/signedagreement_form.html
+++ b/primed/templates/cdsa/signedagreement_form.html
@@ -17,7 +17,6 @@ <h1>{% block agreement_type_title %}{% endblock agreement_type_title %}</h1>
 
     <button type="submit" class="btn btn-success">Save</button>
   </form>
-
 {% endblock content %}
 
 
diff --git a/primed/templates/cdsa/signedagreement_status_update.html b/primed/templates/cdsa/signedagreement_status_update.html
index e3e2b418..c8e88fe9 100644
--- a/primed/templates/cdsa/signedagreement_status_update.html
+++ b/primed/templates/cdsa/signedagreement_status_update.html
@@ -28,7 +28,7 @@
 {% endblock panel %}
 
 {% block after_panel %}
-<div>
+<div class="container m-3">
   <form method="post">
 
     {% csrf_token %}

From 8cd56a89e2a7227d8d6b76c36691e289c1220728 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Mon, 25 Sep 2023 09:43:55 -0700
Subject: [PATCH 51/53] Create the correct CDSA group name for example data

Instead of hardcoding the CDSA group name as "PRIMED_CDSA", use the
name specified in the settings file.
---
 add_cdsa_example_data.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/add_cdsa_example_data.py b/add_cdsa_example_data.py
index c4f9d599..61e28226 100644
--- a/add_cdsa_example_data.py
+++ b/add_cdsa_example_data.py
@@ -9,6 +9,7 @@
     ManagedGroupFactory,
     WorkspaceGroupSharingFactory,
 )
+from django.conf import settings
 
 from primed.cdsa.tests import factories
 from primed.duo.tests.factories import DataUseModifierFactory, DataUsePermissionFactory
@@ -33,7 +34,7 @@
 dum = DataUseModifierFactory.create(abbreviation="NPU")
 
 # create the CDSA auth group
-cdsa_group = ManagedGroupFactory.create(name="PRIMED_CDSA")
+cdsa_group = ManagedGroupFactory.create(name=settings.ANVIL_CDSA_GROUP_NAME)
 
 # Create some study sites.
 StudySiteFactory.create(short_name="CARDINAL", full_name="CARDINAL")

From 7c446297f31081b123ec92ee46903cc5a5d25505 Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 29 Sep 2023 13:52:07 -0700
Subject: [PATCH 52/53] Fix typos

---
 .../cdsa/agreementmajorversion_confirm_invalidate.html          | 2 +-
 primed/templates/cdsa/agreementmajorversion_detail.html         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html b/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html
index 0074fe95..b3a3f7e7 100644
--- a/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html
+++ b/primed/templates/cdsa/agreementmajorversion_confirm_invalidate.html
@@ -14,7 +14,7 @@ <h2>Invalidate Agreement {{ object }}</h2>
 
       <p>Are you sure you want to invalidate Agreement <a href="{{ objectget_absolute_url }}">{{ object }}</a>?</p>
 
-      <p>This will change the status of all "Active" agreementes associated with this version to "Lapsed". </p>
+      <p>This will change the status of all "Active" agreements associated with this version to "Lapsed". </p>
 
       <form method="POST">{% csrf_token %}
           {{ form }}
diff --git a/primed/templates/cdsa/agreementmajorversion_detail.html b/primed/templates/cdsa/agreementmajorversion_detail.html
index f9199b33..9cf7e138 100644
--- a/primed/templates/cdsa/agreementmajorversion_detail.html
+++ b/primed/templates/cdsa/agreementmajorversion_detail.html
@@ -30,7 +30,7 @@ <h3>Agreement versions</h3>
     <h2 class="accordion-header" id="agreements-versions-heading">
       <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#agreements-versions-collapse" aria-expanded="false" aria-controls="signed-agreements-collapse">
         <span class="fa-solid fa-computer mx-2"></span>
-        Signed agreements with this version
+        Agreements with this version
         <span class="badge bg-{% if tables.0.rows|length %}primary{% else %}secondary{% endif %} mx-3"> {{tables.0.rows|length}} </span>
       </button>
     </h2>

From 3dd387f130ee41029e2ef0ed2d25e4c6f12c9a4f Mon Sep 17 00:00:00 2001
From: Adrienne Stilp <amstilp@uw.edu>
Date: Fri, 29 Sep 2023 16:02:47 -0700
Subject: [PATCH 53/53] Remove is_valid propery from AgreementVersion model

This is no longer needed, since we use the AgreementMajorVersion
foreign key to determine validity.
---
 primed/cdsa/models.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/primed/cdsa/models.py b/primed/cdsa/models.py
index 9107ab81..5dd8a053 100644
--- a/primed/cdsa/models.py
+++ b/primed/cdsa/models.py
@@ -90,10 +90,6 @@ def get_absolute_url(self):
     def full_version(self):
         return "{}.{}".format(str(self.major_version), self.minor_version)
 
-    @property
-    def is_valid(self):
-        return True
-
 
 class SignedAgreementStatusMixin:
     """Mixin to define status choices for SignedAgreements."""