\ No newline at end of file
diff --git a/src/registrar/templatetags/custom_filters.py b/src/registrar/templatetags/custom_filters.py
index dc42a5c1d..9fa5c9aa9 100644
--- a/src/registrar/templatetags/custom_filters.py
+++ b/src/registrar/templatetags/custom_filters.py
@@ -62,3 +62,8 @@ def get_organization_long_name(generic_org_type):
return "Error"
return long_form_type
+
+
+@register.filter(name="has_permission")
+def has_permission(user, permission):
+ return user.has_perm(permission)
diff --git a/src/registrar/tests/common.py b/src/registrar/tests/common.py
index 9681b8cb7..b41c2c35c 100644
--- a/src/registrar/tests/common.py
+++ b/src/registrar/tests/common.py
@@ -693,6 +693,24 @@ class MockDb(TestCase):
user=meoward_user, domain=self.domain_12, role=UserDomainRole.Roles.MANAGER
)
+ _, created = DomainInvitation.objects.get_or_create(
+ email=meoward_user.email, domain=self.domain_1, status=DomainInvitation.DomainInvitationStatus.RETRIEVED
+ )
+
+ _, created = DomainInvitation.objects.get_or_create(
+ email="woofwardthethird@rocks.com",
+ domain=self.domain_1,
+ status=DomainInvitation.DomainInvitationStatus.INVITED,
+ )
+
+ _, created = DomainInvitation.objects.get_or_create(
+ email="squeaker@rocks.com", domain=self.domain_2, status=DomainInvitation.DomainInvitationStatus.INVITED
+ )
+
+ _, created = DomainInvitation.objects.get_or_create(
+ email="squeaker@rocks.com", domain=self.domain_10, status=DomainInvitation.DomainInvitationStatus.INVITED
+ )
+
with less_console_noise():
self.domain_request_1 = completed_domain_request(
status=DomainRequest.DomainRequestStatus.STARTED, name="city1.gov"
@@ -722,6 +740,7 @@ class MockDb(TestCase):
DomainRequest.objects.all().delete()
User.objects.all().delete()
UserDomainRole.objects.all().delete()
+ DomainInvitation.objects.all().delete()
def mock_user():
diff --git a/src/registrar/tests/test_admin.py b/src/registrar/tests/test_admin.py
index 46b5e104a..7b810a2c5 100644
--- a/src/registrar/tests/test_admin.py
+++ b/src/registrar/tests/test_admin.py
@@ -129,6 +129,83 @@ class TestDomainAdmin(MockEppLib, WebTest):
)
mock_add_message.assert_has_calls([expected_call], 1)
+ @less_console_noise_decorator
+ def test_analyst_can_see_inline_domain_information_in_domain_change_form(self):
+ """Tests if an analyst can still see the inline domain information form"""
+
+ # Create fake creator
+ _creator = User.objects.create(
+ username="MrMeoward",
+ first_name="Meoward",
+ last_name="Jones",
+ )
+
+ # Create a fake domain request
+ _domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW, user=_creator)
+
+ # Creates a Domain and DomainInformation object
+ _domain_request.approve()
+
+ domain_information = DomainInformation.objects.filter(domain_request=_domain_request).get()
+ domain_information.organization_name = "MonkeySeeMonkeyDo"
+ domain_information.save()
+
+ # We use filter here rather than just domain_information.domain just to get the latest data.
+ domain = Domain.objects.filter(domain_info=domain_information).get()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domain/{}/change/".format(domain.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain.name)
+
+ # Test for data. We only need to test one since its all interconnected.
+ expected_organization_name = "MonkeySeeMonkeyDo"
+ self.assertContains(response, expected_organization_name)
+
+ @less_console_noise_decorator
+ def test_admin_can_see_inline_domain_information_in_domain_change_form(self):
+ """Tests if an admin can still see the inline domain information form"""
+ # Create fake creator
+ _creator = User.objects.create(
+ username="MrMeoward",
+ first_name="Meoward",
+ last_name="Jones",
+ )
+
+ # Create a fake domain request
+ _domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW, user=_creator)
+
+ # Creates a Domain and DomainInformation object
+ _domain_request.approve()
+
+ domain_information = DomainInformation.objects.filter(domain_request=_domain_request).get()
+ domain_information.organization_name = "MonkeySeeMonkeyDo"
+ domain_information.save()
+
+ # We use filter here rather than just domain_information.domain just to get the latest data.
+ domain = Domain.objects.filter(domain_info=domain_information).get()
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domain/{}/change/".format(domain.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain.name)
+
+ # Test for data. We only need to test one since its all interconnected.
+ expected_organization_name = "MonkeySeeMonkeyDo"
+ self.assertContains(response, expected_organization_name)
+
@patch("registrar.admin.DomainAdmin._get_current_date", return_value=date(2024, 1, 1))
def test_extend_expiration_date_button_epp(self, mock_date_today):
"""
@@ -706,15 +783,26 @@ class TestDomainRequestAdmin(MockEppLib):
with less_console_noise():
self.client.force_login(self.superuser)
completed_domain_request()
- response = self.client.get("/admin/registrar/domainrequest/")
- # There are 4 template references to Federal (4) plus two references in the table
- # for our actual domain request
+ response = self.client.get("/admin/registrar/domainrequest/?generic_org_type__exact=federal")
+ # There are 2 template references to Federal (4) and two in the results data
+ # of the request
self.assertContains(response, "Federal", count=34)
# This may be a bit more robust
self.assertContains(response, '
', count=1)
# Now let's make sure the long description does not exist
self.assertNotContains(response, "Federal: an agency of the U.S. government")
+ def test_default_status_in_domain_requests_list(self):
+ """
+ Make sure the default status in admin is selected on the domain requests list page
+ """
+ with less_console_noise():
+ self.client.force_login(self.superuser)
+ completed_domain_request()
+ response = self.client.get("/admin/registrar/domainrequest/")
+ # The results are filtered by "status in [submitted,in review,action needed]"
+ self.assertContains(response, "status in [submitted,in review,action needed]", count=1)
+
def transition_state_and_send_email(self, domain_request, status, rejection_reason=None):
"""Helper method for the email test cases."""
@@ -1213,6 +1301,61 @@ class TestDomainRequestAdmin(MockEppLib):
self.assertEqual(domain_request.requested_domain.name, domain_request.approved_domain.name)
@less_console_noise_decorator
+ def test_sticky_submit_row(self):
+ """Test that the change_form template contains strings indicative of the customization
+ of the sticky submit bar.
+
+ Also test that it does NOT contain a CSS class meant for analysts only when logged in as superuser."""
+
+ # make sure there is no user with this email
+ EMAIL = "mayor@igorville.gov"
+ User.objects.filter(email=EMAIL).delete()
+ self.client.force_login(self.superuser)
+
+ # Create a sample domain request
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
+
+ # Create a mock request
+ request = self.client.post("/admin/registrar/domainrequest/{}/change/".format(domain_request.pk))
+
+ # Since we're using client to mock the request, we can only test against
+ # non-interpolated values
+ expected_content = "
'
+ not_expected_content = "submit-row-wrapper--analyst-view>"
+ self.assertContains(request, expected_content)
+ self.assertContains(request, expected_content2)
+ self.assertContains(request, expected_content3)
+ self.assertNotContains(request, not_expected_content)
+
+ @less_console_noise_decorator
+ def test_sticky_submit_row_has_extra_class_for_analysts(self):
+ """Test that the change_form template contains strings indicative of the customization
+ of the sticky submit bar.
+
+ Also test that it DOES contain a CSS class meant for analysts only when logged in as analyst."""
+
+ # make sure there is no user with this email
+ EMAIL = "mayor@igorville.gov"
+ User.objects.filter(email=EMAIL).delete()
+ self.client.force_login(self.staffuser)
+
+ # Create a sample domain request
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
+
+ # Create a mock request
+ request = self.client.post("/admin/registrar/domainrequest/{}/change/".format(domain_request.pk))
+
+ # Since we're using client to mock the request, we can only test against
+ # non-interpolated values
+ expected_content = "
Requested domain:"
+ expected_content2 = '
'
+ expected_content3 = '
'
+ self.assertContains(request, expected_content)
+ self.assertContains(request, expected_content2)
+ self.assertContains(request, expected_content3)
+
def test_other_contacts_has_readonly_link(self):
"""Tests if the readonly other_contacts field has links"""
@@ -1665,7 +1808,7 @@ class TestDomainRequestAdmin(MockEppLib):
# Grab the current list of table filters
readonly_fields = self.admin.get_list_filter(request)
expected_fields = (
- "status",
+ DomainRequestAdmin.StatusListFilter,
"generic_org_type",
"federal_type",
DomainRequestAdmin.ElectionOfficeFilter,
@@ -1961,8 +2104,8 @@ class TestDomainInformationAdmin(TestCase):
# Get the other contact
other_contact = domain_info.other_contacts.all().first()
- p = "userpass"
- self.client.login(username="staffuser", password=p)
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
response = self.client.get(
"/admin/registrar/domaininformation/{}/change/".format(domain_info.pk),
@@ -1983,6 +2126,44 @@ class TestDomainInformationAdmin(TestCase):
expected_url = "Testy Tester"
self.assertContains(response, expected_url)
+ @less_console_noise_decorator
+ def test_analyst_cant_access_domain_information(self):
+ """Ensures that analysts can't directly access the DomainInformation page through /admin"""
+ # Create fake creator
+ _creator = User.objects.create(
+ username="MrMeoward",
+ first_name="Meoward",
+ last_name="Jones",
+ )
+
+ # Create a fake domain request
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW, user=_creator)
+ domain_request.approve()
+ domain_info = DomainInformation.objects.filter(domain=domain_request.approved_domain).get()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domaininformation/{}/change/".format(domain_info.pk),
+ follow=True,
+ )
+
+ # Make sure that we're denied access
+ self.assertEqual(response.status_code, 403)
+
+ # To make sure that its not a fluke, swap to an admin user
+ # and try to access the same page. This should succeed.
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domaininformation/{}/change/".format(domain_info.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain_info.domain.name)
+
@less_console_noise_decorator
def test_contact_fields_have_detail_table(self):
"""Tests if the contact fields have the detail table which displays title, email, and phone"""
@@ -2006,8 +2187,8 @@ class TestDomainInformationAdmin(TestCase):
domain_request.approve()
domain_info = DomainInformation.objects.filter(domain=domain_request.approved_domain).get()
- p = "userpass"
- self.client.login(username="staffuser", password=p)
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
response = self.client.get(
"/admin/registrar/domaininformation/{}/change/".format(domain_info.pk),
follow=True,
diff --git a/src/registrar/tests/test_migrations.py b/src/registrar/tests/test_migrations.py
index bf3b09d0d..add65105a 100644
--- a/src/registrar/tests/test_migrations.py
+++ b/src/registrar/tests/test_migrations.py
@@ -34,7 +34,6 @@ class TestGroups(TestCase):
"view_logentry",
"change_contact",
"view_domain",
- "change_domaininformation",
"add_domaininvitation",
"view_domaininvitation",
"change_domainrequest",
diff --git a/src/registrar/tests/test_reports.py b/src/registrar/tests/test_reports.py
index 459ccde0f..6299349c5 100644
--- a/src/registrar/tests/test_reports.py
+++ b/src/registrar/tests/test_reports.py
@@ -9,10 +9,10 @@ from registrar.utility.csv_export import (
export_data_unmanaged_domains_to_csv,
get_sliced_domains,
get_sliced_requests,
- write_domains_csv,
+ write_csv_for_domains,
get_default_start_date,
get_default_end_date,
- write_requests_csv,
+ write_csv_for_requests,
)
from django.core.management import call_command
@@ -242,8 +242,13 @@ class ExportDataTest(MockDb, MockEppLib):
}
self.maxDiff = None
# Call the export functions
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer,
+ columns,
+ sort_fields,
+ filter_condition,
+ should_get_domain_managers=False,
+ should_write_header=True,
)
# Reset the CSV file's position to the beginning
@@ -268,7 +273,7 @@ class ExportDataTest(MockDb, MockEppLib):
expected_content = expected_content.replace(",,", "").replace(",", "").replace(" ", "").strip()
self.assertEqual(csv_content, expected_content)
- def test_write_domains_csv(self):
+ def test_write_csv_for_domains(self):
"""Test that write_body returns the
existing domain, test that sort by domain name works,
test that filter works"""
@@ -304,8 +309,13 @@ class ExportDataTest(MockDb, MockEppLib):
],
}
# Call the export functions
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer,
+ columns,
+ sort_fields,
+ filter_condition,
+ should_get_domain_managers=False,
+ should_write_header=True,
)
# Reset the CSV file's position to the beginning
csv_file.seek(0)
@@ -357,8 +367,13 @@ class ExportDataTest(MockDb, MockEppLib):
],
}
# Call the export functions
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer,
+ columns,
+ sort_fields,
+ filter_condition,
+ should_get_domain_managers=False,
+ should_write_header=True,
)
# Reset the CSV file's position to the beginning
csv_file.seek(0)
@@ -433,20 +448,20 @@ class ExportDataTest(MockDb, MockEppLib):
}
# Call the export functions
- write_domains_csv(
+ write_csv_for_domains(
writer,
columns,
sort_fields,
filter_condition,
- get_domain_managers=False,
+ should_get_domain_managers=False,
should_write_header=True,
)
- write_domains_csv(
+ write_csv_for_domains(
writer,
columns,
sort_fields_for_deleted_domains,
filter_conditions_for_deleted_domains,
- get_domain_managers=False,
+ should_get_domain_managers=False,
should_write_header=False,
)
# Reset the CSV file's position to the beginning
@@ -478,7 +493,12 @@ class ExportDataTest(MockDb, MockEppLib):
def test_export_domains_to_writer_domain_managers(self):
"""Test that export_domains_to_writer returns the
- expected domain managers."""
+ expected domain managers.
+
+ An invited user, woofwardthethird, should also be pulled into this report.
+
+ squeaker@rocks.com is invited to domain2 (DNS_NEEDED) and domain10 (No managers).
+ She should show twice in this report but not in test_export_data_managed_domains_to_csv."""
with less_console_noise():
# Create a CSV file in memory
@@ -508,8 +528,13 @@ class ExportDataTest(MockDb, MockEppLib):
}
self.maxDiff = None
# Call the export functions
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=True, should_write_header=True
+ write_csv_for_domains(
+ writer,
+ columns,
+ sort_fields,
+ filter_condition,
+ should_get_domain_managers=True,
+ should_write_header=True,
)
# Reset the CSV file's position to the beginning
@@ -521,14 +546,16 @@ class ExportDataTest(MockDb, MockEppLib):
expected_content = (
"Domain name,Status,Expiration date,Domain type,Agency,"
"Organization name,City,State,AO,AO email,"
- "Security contact email,Domain manager email 1,Domain manager email 2,Domain manager email 3\n"
- "adomain10.gov,Ready,,Federal,Armed Forces Retirement Home,,,, , ,\n"
- "adomain2.gov,Dns needed,,Interstate,,,,, , , ,meoward@rocks.com\n"
- "cdomain11.govReadyFederal-ExecutiveWorldWarICentennialCommissionmeoward@rocks.com\n"
+ "Security contact email,Domain manager 1,DM1 status,Domain manager 2,DM2 status,"
+ "Domain manager 3,DM3 status,Domain manager 4,DM4 status\n"
+ "adomain10.gov,Ready,,Federal,Armed Forces Retirement Home,,,, , ,squeaker@rocks.com, I\n"
+ "adomain2.gov,Dns needed,,Interstate,,,,, , , ,meoward@rocks.com, R,squeaker@rocks.com, I\n"
+ "cdomain11.govReadyFederal-ExecutiveWorldWarICentennialCommissionmeoward@rocks.comR\n"
"cdomain1.gov,Ready,,Federal - Executive,World War I Centennial Commission,,,"
- ", , , ,meoward@rocks.com,info@example.com,big_lebowski@dude.co\n"
+ ", , , ,meoward@rocks.com,R,info@example.com,R,big_lebowski@dude.co,R,"
+ "woofwardthethird@rocks.com,I\n"
"ddomain3.gov,On hold,,Federal,Armed Forces Retirement Home,,,, , , ,,\n"
- "zdomain12.govReadyInterstatemeoward@rocks.com\n"
+ "zdomain12.govReadyInterstatemeoward@rocks.comR\n"
)
# Normalize line endings and remove commas,
# spaces and leading/trailing whitespace
@@ -538,7 +565,9 @@ class ExportDataTest(MockDb, MockEppLib):
def test_export_data_managed_domains_to_csv(self):
"""Test get counts for domains that have domain managers for two different dates,
- get list of managed domains at end_date."""
+ get list of managed domains at end_date.
+
+ An invited user, woofwardthethird, should also be pulled into this report."""
with less_console_noise():
# Create a CSV file in memory
@@ -564,10 +593,12 @@ class ExportDataTest(MockDb, MockEppLib):
"Special district,School district,Election office\n"
"3,2,1,0,0,0,0,0,0,0\n"
"\n"
- "Domain name,Domain type,Domain manager email 1,Domain manager email 2,Domain manager email 3\n"
- "cdomain11.govFederal-Executivemeoward@rocks.com\n"
- "cdomain1.gov,Federal - Executive,meoward@rocks.com,info@example.com,big_lebowski@dude.co\n"
- "zdomain12.govInterstatemeoward@rocks.com\n"
+ "Domain name,Domain type,Domain manager 1,DM1 status,Domain manager 2,DM2 status,"
+ "Domain manager 3,DM3 status,Domain manager 4,DM4 status\n"
+ "cdomain11.govFederal-Executivemeoward@rocks.com, R\n"
+ "cdomain1.gov,Federal - Executive,meoward@rocks.com,R,info@example.com,R,"
+ "big_lebowski@dude.co,R,woofwardthethird@rocks.com,I\n"
+ "zdomain12.govInterstatemeoward@rocks.com,R\n"
)
# Normalize line endings and remove commas,
@@ -642,7 +673,7 @@ class ExportDataTest(MockDb, MockEppLib):
"submission_date__lte": self.end_date,
"submission_date__gte": self.start_date,
}
- write_requests_csv(writer, columns, sort_fields, filter_condition, should_write_header=True)
+ write_csv_for_requests(writer, columns, sort_fields, filter_condition, should_write_header=True)
# Reset the CSV file's position to the beginning
csv_file.seek(0)
# Read the content into a variable
@@ -686,7 +717,7 @@ class HelperFunctions(MockDb):
"domain__first_ready__lte": self.end_date,
}
# Test with distinct
- managed_domains_sliced_at_end_date = get_sliced_domains(filter_condition, True)
+ managed_domains_sliced_at_end_date = get_sliced_domains(filter_condition)
expected_content = [3, 2, 1, 0, 0, 0, 0, 0, 0, 0]
self.assertEqual(managed_domains_sliced_at_end_date, expected_content)
diff --git a/src/registrar/tests/test_views_application.py b/src/registrar/tests/test_views_request.py
similarity index 100%
rename from src/registrar/tests/test_views_application.py
rename to src/registrar/tests/test_views_request.py
diff --git a/src/registrar/utility/csv_export.py b/src/registrar/utility/csv_export.py
index 7fc710827..949b0adcd 100644
--- a/src/registrar/utility/csv_export.py
+++ b/src/registrar/utility/csv_export.py
@@ -1,8 +1,8 @@
-from collections import Counter
import csv
import logging
from datetime import datetime
from registrar.models.domain import Domain
+from registrar.models.domain_invitation import DomainInvitation
from registrar.models.domain_request import DomainRequest
from registrar.models.domain_information import DomainInformation
from django.utils import timezone
@@ -11,6 +11,7 @@ from django.db.models import F, Value, CharField
from django.db.models.functions import Concat, Coalesce
from registrar.models.public_contact import PublicContact
+from registrar.models.user_domain_role import UserDomainRole
from registrar.utility.enums import DefaultEmail
logger = logging.getLogger(__name__)
@@ -33,7 +34,6 @@ def get_domain_infos(filter_condition, sort_fields):
"""
domain_infos = (
DomainInformation.objects.select_related("domain", "authorizing_official")
- .prefetch_related("domain__permissions")
.filter(**filter_condition)
.order_by(*sort_fields)
.distinct()
@@ -53,7 +53,14 @@ def get_domain_infos(filter_condition, sort_fields):
return domain_infos_cleaned
-def parse_domain_row(columns, domain_info: DomainInformation, security_emails_dict=None, get_domain_managers=False):
+def parse_row_for_domain(
+ columns,
+ domain_info: DomainInformation,
+ dict_security_emails=None,
+ should_get_domain_managers=False,
+ dict_domain_invitations_with_invited_status=None,
+ dict_user_domain_roles=None,
+):
"""Given a set of columns, generate a new row from cleaned column data"""
# Domain should never be none when parsing this information
@@ -65,8 +72,8 @@ def parse_domain_row(columns, domain_info: DomainInformation, security_emails_di
# Grab the security email from a preset dictionary.
# If nothing exists in the dictionary, grab from .contacts.
- if security_emails_dict is not None and domain.name in security_emails_dict:
- _email = security_emails_dict.get(domain.name)
+ if dict_security_emails is not None and domain.name in dict_security_emails:
+ _email = dict_security_emails.get(domain.name)
security_email = _email if _email is not None else " "
else:
# If the dictionary doesn't contain that data, lets filter for it manually.
@@ -103,13 +110,22 @@ def parse_domain_row(columns, domain_info: DomainInformation, security_emails_di
"Deleted": domain.deleted,
}
- if get_domain_managers:
- # Get each domain managers email and add to list
- dm_emails = [dm.user.email for dm in domain.permissions.all()]
+ if should_get_domain_managers:
+ # Get lists of emails for active and invited domain managers
- # Set up the "matching header" + row field data
- for i, dm_email in enumerate(dm_emails, start=1):
- FIELDS[f"Domain manager email {i}"] = dm_email
+ dms_active_emails = dict_user_domain_roles.get(domain_info.domain.name, [])
+ dms_invited_emails = dict_domain_invitations_with_invited_status.get(domain_info.domain.name, [])
+
+ # Set up the "matching headers" + row field data for email and status
+ i = 0 # Declare i outside of the loop to avoid a reference before assignment in the second loop
+ for i, dm_email in enumerate(dms_active_emails, start=1):
+ FIELDS[f"Domain manager {i}"] = dm_email
+ FIELDS[f"DM{i} status"] = "R"
+
+ # Continue enumeration from where we left off and add data for invited domain managers
+ for j, dm_email in enumerate(dms_invited_emails, start=i + 1):
+ FIELDS[f"Domain manager {j}"] = dm_email
+ FIELDS[f"DM{j} status"] = "I"
row = [FIELDS.get(column, "") for column in columns]
return row
@@ -119,7 +135,7 @@ def _get_security_emails(sec_contact_ids):
"""
Retrieve security contact emails for the given security contact IDs.
"""
- security_emails_dict = {}
+ dict_security_emails = {}
public_contacts = (
PublicContact.objects.only("email", "domain__name")
.select_related("domain")
@@ -129,65 +145,151 @@ def _get_security_emails(sec_contact_ids):
# Populate a dictionary of domain names and their security contacts
for contact in public_contacts:
domain: Domain = contact.domain
- if domain is not None and domain.name not in security_emails_dict:
- security_emails_dict[domain.name] = contact.email
+ if domain is not None and domain.name not in dict_security_emails:
+ dict_security_emails[domain.name] = contact.email
else:
logger.warning("csv_export -> Domain was none for PublicContact")
- return security_emails_dict
+ return dict_security_emails
-def write_domains_csv(
+def count_domain_managers(domain_name, dict_domain_invitations_with_invited_status, dict_user_domain_roles):
+ """Count active and invited domain managers"""
+ dms_active = len(dict_user_domain_roles.get(domain_name, []))
+ dms_invited = len(dict_domain_invitations_with_invited_status.get(domain_name, []))
+ return dms_active, dms_invited
+
+
+def update_columns(columns, dms_total, should_update_columns):
+ """Update columns if necessary"""
+ if should_update_columns:
+ for i in range(1, dms_total + 1):
+ email_column_header = f"Domain manager {i}"
+ status_column_header = f"DM{i} status"
+ if email_column_header not in columns:
+ columns.append(email_column_header)
+ columns.append(status_column_header)
+ should_update_columns = False
+ return columns, should_update_columns, dms_total
+
+
+def update_columns_with_domain_managers(
+ columns,
+ domain_info,
+ should_update_columns,
+ dms_total,
+ dict_domain_invitations_with_invited_status,
+ dict_user_domain_roles,
+):
+ """Helper function to update columns with domain manager information"""
+
+ domain_name = domain_info.domain.name
+
+ try:
+ dms_active, dms_invited = count_domain_managers(
+ domain_name, dict_domain_invitations_with_invited_status, dict_user_domain_roles
+ )
+
+ if dms_active + dms_invited > dms_total:
+ dms_total = dms_active + dms_invited
+ should_update_columns = True
+
+ except Exception as err:
+ logger.error(f"Exception while parsing domain managers for reports: {err}")
+
+ return update_columns(columns, dms_total, should_update_columns)
+
+
+def build_dictionaries_for_domain_managers(dict_user_domain_roles, dict_domain_invitations_with_invited_status):
+ """Helper function that builds dicts for invited users and active domain
+ managers. We do so to avoid filtering within loops."""
+
+ user_domain_roles = UserDomainRole.objects.all()
+
+ # Iterate through each user domain role and populate the dictionary
+ for user_domain_role in user_domain_roles:
+ domain_name = user_domain_role.domain.name
+ email = user_domain_role.user.email
+ if domain_name not in dict_user_domain_roles:
+ dict_user_domain_roles[domain_name] = []
+ dict_user_domain_roles[domain_name].append(email)
+
+ domain_invitations_with_invited_status = None
+ domain_invitations_with_invited_status = DomainInvitation.objects.filter(
+ status=DomainInvitation.DomainInvitationStatus.INVITED
+ ).select_related("domain")
+
+ # Iterate through each domain invitation and populate the dictionary
+ for invite in domain_invitations_with_invited_status:
+ domain_name = invite.domain.name
+ email = invite.email
+ if domain_name not in dict_domain_invitations_with_invited_status:
+ dict_domain_invitations_with_invited_status[domain_name] = []
+ dict_domain_invitations_with_invited_status[domain_name].append(email)
+
+ return dict_user_domain_roles, dict_domain_invitations_with_invited_status
+
+
+def write_csv_for_domains(
writer,
columns,
sort_fields,
filter_condition,
- get_domain_managers=False,
+ should_get_domain_managers=False,
should_write_header=True,
):
"""
Receives params from the parent methods and outputs a CSV with filtered and sorted domains.
Works with write_header as long as the same writer object is passed.
- get_domain_managers: Conditional bc we only use domain manager info for export_data_full_to_csv
+ should_get_domain_managers: Conditional bc we only use domain manager info for export_data_full_to_csv
should_write_header: Conditional bc export_data_domain_growth_to_csv calls write_body twice
"""
+ # Retrieve domain information and all sec emails
all_domain_infos = get_domain_infos(filter_condition, sort_fields)
-
- # Store all security emails to avoid epp calls or excessive filters
sec_contact_ids = all_domain_infos.values_list("domain__security_contact_registry_id", flat=True)
-
- security_emails_dict = _get_security_emails(sec_contact_ids)
-
- # Reduce the memory overhead when performing the write operation
+ dict_security_emails = _get_security_emails(sec_contact_ids)
paginator = Paginator(all_domain_infos, 1000)
- # The maximum amount of domain managers an account has
- # We get the max so we can set the column header accurately
- max_dm_count = 0
+ # Initialize variables
+ dms_total = 0
+ should_update_columns = False
total_body_rows = []
+ dict_user_domain_roles = {}
+ dict_domain_invitations_with_invited_status = {}
+ # Build dictionaries if necessary
+ if should_get_domain_managers:
+ dict_user_domain_roles, dict_domain_invitations_with_invited_status = build_dictionaries_for_domain_managers(
+ dict_user_domain_roles, dict_domain_invitations_with_invited_status
+ )
+
+ # Process domain information
for page_num in paginator.page_range:
rows = []
page = paginator.page(page_num)
for domain_info in page.object_list:
-
- # Get count of all the domain managers for an account
- if get_domain_managers:
- dm_count = domain_info.domain.permissions.count()
- if dm_count > max_dm_count:
- max_dm_count = dm_count
- for i in range(1, max_dm_count + 1):
- column_name = f"Domain manager email {i}"
- if column_name not in columns:
- columns.append(column_name)
+ if should_get_domain_managers:
+ columns, dms_total, should_update_columns = update_columns_with_domain_managers(
+ columns,
+ domain_info,
+ should_update_columns,
+ dms_total,
+ dict_domain_invitations_with_invited_status,
+ dict_user_domain_roles,
+ )
try:
- row = parse_domain_row(columns, domain_info, security_emails_dict, get_domain_managers)
+ row = parse_row_for_domain(
+ columns,
+ domain_info,
+ dict_security_emails,
+ should_get_domain_managers,
+ dict_domain_invitations_with_invited_status,
+ dict_user_domain_roles,
+ )
rows.append(row)
except ValueError:
- # This should not happen. If it does, just skip this row.
- # It indicates that DomainInformation.domain is None.
logger.error("csv_export -> Error when parsing row, domain was None")
continue
total_body_rows.extend(rows)
@@ -208,7 +310,7 @@ def get_requests(filter_condition, sort_fields):
return requests
-def parse_request_row(columns, request: DomainRequest):
+def parse_row_for_requests(columns, request: DomainRequest):
"""Given a set of columns, generate a new row from cleaned column data"""
requested_domain_name = "No requested domain"
@@ -240,7 +342,7 @@ def parse_request_row(columns, request: DomainRequest):
return row
-def write_requests_csv(
+def write_csv_for_requests(
writer,
columns,
sort_fields,
@@ -261,7 +363,7 @@ def write_requests_csv(
rows = []
for request in page.object_list:
try:
- row = parse_request_row(columns, request)
+ row = parse_row_for_requests(columns, request)
rows.append(row)
except ValueError:
# This should not happen. If it does, just skip this row.
@@ -309,8 +411,8 @@ def export_data_type_to_csv(csv_file):
Domain.State.ON_HOLD,
],
}
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=True, should_write_header=True
+ write_csv_for_domains(
+ writer, columns, sort_fields, filter_condition, should_get_domain_managers=True, should_write_header=True
)
@@ -342,8 +444,8 @@ def export_data_full_to_csv(csv_file):
Domain.State.ON_HOLD,
],
}
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer, columns, sort_fields, filter_condition, should_get_domain_managers=False, should_write_header=True
)
@@ -376,8 +478,8 @@ def export_data_federal_to_csv(csv_file):
Domain.State.ON_HOLD,
],
}
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer, columns, sort_fields, filter_condition, should_get_domain_managers=False, should_write_header=True
)
@@ -446,77 +548,42 @@ def export_data_domain_growth_to_csv(csv_file, start_date, end_date):
"domain__deleted__gte": start_date_formatted,
}
- write_domains_csv(
- writer, columns, sort_fields, filter_condition, get_domain_managers=False, should_write_header=True
+ write_csv_for_domains(
+ writer, columns, sort_fields, filter_condition, should_get_domain_managers=False, should_write_header=True
)
- write_domains_csv(
+ write_csv_for_domains(
writer,
columns,
sort_fields_for_deleted_domains,
filter_condition_for_deleted_domains,
- get_domain_managers=False,
+ should_get_domain_managers=False,
should_write_header=False,
)
-def get_sliced_domains(filter_condition, distinct=False):
+def get_sliced_domains(filter_condition):
"""Get filtered domains counts sliced by org type and election office.
Pass distinct=True when filtering by permissions so we do not to count multiples
when a domain has more that one manager.
"""
- # Round trip 1: Get distinct domain names based on filter condition
- domains_count = DomainInformation.objects.filter(**filter_condition).distinct().count()
-
- # Round trip 2: Get counts for other slices
- # This will require either 8 filterd and distinct DB round trips,
- # or 2 DB round trips plus iteration on domain_permissions for each domain
- if distinct:
- generic_org_types_query = DomainInformation.objects.filter(**filter_condition).values_list(
- "domain_id", "generic_org_type"
- )
- # Initialize Counter to store counts for each generic_org_type
- generic_org_type_counts = Counter()
-
- # Keep track of domains already counted
- domains_counted = set()
-
- # Iterate over distinct domains
- for domain_id, generic_org_type in generic_org_types_query:
- # Check if the domain has already been counted
- if domain_id in domains_counted:
- continue
-
- # Get all permissions for the current domain
- domain_permissions = DomainInformation.objects.filter(domain_id=domain_id, **filter_condition).values_list(
- "domain__permissions", flat=True
- )
-
- # Check if the domain has multiple permissions
- if len(domain_permissions) > 0:
- # Mark the domain as counted
- domains_counted.add(domain_id)
-
- # Increment the count for the corresponding generic_org_type
- generic_org_type_counts[generic_org_type] += 1
- else:
- generic_org_types_query = DomainInformation.objects.filter(**filter_condition).values_list(
- "generic_org_type", flat=True
- )
- generic_org_type_counts = Counter(generic_org_types_query)
-
- # Extract counts for each generic_org_type
- federal = generic_org_type_counts.get(DomainRequest.OrganizationChoices.FEDERAL, 0)
- interstate = generic_org_type_counts.get(DomainRequest.OrganizationChoices.INTERSTATE, 0)
- state_or_territory = generic_org_type_counts.get(DomainRequest.OrganizationChoices.STATE_OR_TERRITORY, 0)
- tribal = generic_org_type_counts.get(DomainRequest.OrganizationChoices.TRIBAL, 0)
- county = generic_org_type_counts.get(DomainRequest.OrganizationChoices.COUNTY, 0)
- city = generic_org_type_counts.get(DomainRequest.OrganizationChoices.CITY, 0)
- special_district = generic_org_type_counts.get(DomainRequest.OrganizationChoices.SPECIAL_DISTRICT, 0)
- school_district = generic_org_type_counts.get(DomainRequest.OrganizationChoices.SCHOOL_DISTRICT, 0)
-
- # Round trip 3
- election_board = DomainInformation.objects.filter(is_election_board=True, **filter_condition).distinct().count()
+ domains = DomainInformation.objects.all().filter(**filter_condition).distinct()
+ domains_count = domains.count()
+ federal = domains.filter(generic_org_type=DomainRequest.OrganizationChoices.FEDERAL).distinct().count()
+ interstate = domains.filter(generic_org_type=DomainRequest.OrganizationChoices.INTERSTATE).count()
+ state_or_territory = (
+ domains.filter(generic_org_type=DomainRequest.OrganizationChoices.STATE_OR_TERRITORY).distinct().count()
+ )
+ tribal = domains.filter(generic_org_type=DomainRequest.OrganizationChoices.TRIBAL).distinct().count()
+ county = domains.filter(generic_org_type=DomainRequest.OrganizationChoices.COUNTY).distinct().count()
+ city = domains.filter(generic_org_type=DomainRequest.OrganizationChoices.CITY).distinct().count()
+ special_district = (
+ domains.filter(generic_org_type=DomainRequest.OrganizationChoices.SPECIAL_DISTRICT).distinct().count()
+ )
+ school_district = (
+ domains.filter(generic_org_type=DomainRequest.OrganizationChoices.SCHOOL_DISTRICT).distinct().count()
+ )
+ election_board = domains.filter(is_election_board=True).distinct().count()
return [
domains_count,
@@ -535,26 +602,23 @@ def get_sliced_domains(filter_condition, distinct=False):
def get_sliced_requests(filter_condition):
"""Get filtered requests counts sliced by org type and election office."""
- # Round trip 1: Get distinct requests based on filter condition
- requests_count = DomainRequest.objects.filter(**filter_condition).distinct().count()
-
- # Round trip 2: Get counts for other slices
- generic_org_types_query = DomainRequest.objects.filter(**filter_condition).values_list(
- "generic_org_type", flat=True
+ requests = DomainRequest.objects.all().filter(**filter_condition).distinct()
+ requests_count = requests.count()
+ federal = requests.filter(generic_org_type=DomainRequest.OrganizationChoices.FEDERAL).distinct().count()
+ interstate = requests.filter(generic_org_type=DomainRequest.OrganizationChoices.INTERSTATE).distinct().count()
+ state_or_territory = (
+ requests.filter(generic_org_type=DomainRequest.OrganizationChoices.STATE_OR_TERRITORY).distinct().count()
)
- generic_org_type_counts = Counter(generic_org_types_query)
-
- federal = generic_org_type_counts.get(DomainRequest.OrganizationChoices.FEDERAL, 0)
- interstate = generic_org_type_counts.get(DomainRequest.OrganizationChoices.INTERSTATE, 0)
- state_or_territory = generic_org_type_counts.get(DomainRequest.OrganizationChoices.STATE_OR_TERRITORY, 0)
- tribal = generic_org_type_counts.get(DomainRequest.OrganizationChoices.TRIBAL, 0)
- county = generic_org_type_counts.get(DomainRequest.OrganizationChoices.COUNTY, 0)
- city = generic_org_type_counts.get(DomainRequest.OrganizationChoices.CITY, 0)
- special_district = generic_org_type_counts.get(DomainRequest.OrganizationChoices.SPECIAL_DISTRICT, 0)
- school_district = generic_org_type_counts.get(DomainRequest.OrganizationChoices.SCHOOL_DISTRICT, 0)
-
- # Round trip 3
- election_board = DomainRequest.objects.filter(is_election_board=True, **filter_condition).distinct().count()
+ tribal = requests.filter(generic_org_type=DomainRequest.OrganizationChoices.TRIBAL).distinct().count()
+ county = requests.filter(generic_org_type=DomainRequest.OrganizationChoices.COUNTY).distinct().count()
+ city = requests.filter(generic_org_type=DomainRequest.OrganizationChoices.CITY).distinct().count()
+ special_district = (
+ requests.filter(generic_org_type=DomainRequest.OrganizationChoices.SPECIAL_DISTRICT).distinct().count()
+ )
+ school_district = (
+ requests.filter(generic_org_type=DomainRequest.OrganizationChoices.SCHOOL_DISTRICT).distinct().count()
+ )
+ election_board = requests.filter(is_election_board=True).distinct().count()
return [
requests_count,
@@ -588,7 +652,7 @@ def export_data_managed_domains_to_csv(csv_file, start_date, end_date):
"domain__permissions__isnull": False,
"domain__first_ready__lte": start_date_formatted,
}
- managed_domains_sliced_at_start_date = get_sliced_domains(filter_managed_domains_start_date, True)
+ managed_domains_sliced_at_start_date = get_sliced_domains(filter_managed_domains_start_date)
writer.writerow(["MANAGED DOMAINS COUNTS AT START DATE"])
writer.writerow(
@@ -612,7 +676,7 @@ def export_data_managed_domains_to_csv(csv_file, start_date, end_date):
"domain__permissions__isnull": False,
"domain__first_ready__lte": end_date_formatted,
}
- managed_domains_sliced_at_end_date = get_sliced_domains(filter_managed_domains_end_date, True)
+ managed_domains_sliced_at_end_date = get_sliced_domains(filter_managed_domains_end_date)
writer.writerow(["MANAGED DOMAINS COUNTS AT END DATE"])
writer.writerow(
@@ -632,12 +696,12 @@ def export_data_managed_domains_to_csv(csv_file, start_date, end_date):
writer.writerow(managed_domains_sliced_at_end_date)
writer.writerow([])
- write_domains_csv(
+ write_csv_for_domains(
writer,
columns,
sort_fields,
filter_managed_domains_end_date,
- get_domain_managers=True,
+ should_get_domain_managers=True,
should_write_header=True,
)
@@ -661,7 +725,7 @@ def export_data_unmanaged_domains_to_csv(csv_file, start_date, end_date):
"domain__permissions__isnull": True,
"domain__first_ready__lte": start_date_formatted,
}
- unmanaged_domains_sliced_at_start_date = get_sliced_domains(filter_unmanaged_domains_start_date, True)
+ unmanaged_domains_sliced_at_start_date = get_sliced_domains(filter_unmanaged_domains_start_date)
writer.writerow(["UNMANAGED DOMAINS AT START DATE"])
writer.writerow(
@@ -685,7 +749,7 @@ def export_data_unmanaged_domains_to_csv(csv_file, start_date, end_date):
"domain__permissions__isnull": True,
"domain__first_ready__lte": end_date_formatted,
}
- unmanaged_domains_sliced_at_end_date = get_sliced_domains(filter_unmanaged_domains_end_date, True)
+ unmanaged_domains_sliced_at_end_date = get_sliced_domains(filter_unmanaged_domains_end_date)
writer.writerow(["UNMANAGED DOMAINS AT END DATE"])
writer.writerow(
@@ -705,12 +769,12 @@ def export_data_unmanaged_domains_to_csv(csv_file, start_date, end_date):
writer.writerow(unmanaged_domains_sliced_at_end_date)
writer.writerow([])
- write_domains_csv(
+ write_csv_for_domains(
writer,
columns,
sort_fields,
filter_unmanaged_domains_end_date,
- get_domain_managers=False,
+ should_get_domain_managers=False,
should_write_header=True,
)
@@ -741,4 +805,4 @@ def export_data_requests_growth_to_csv(csv_file, start_date, end_date):
"submission_date__gte": start_date_formatted,
}
- write_requests_csv(writer, columns, sort_fields, filter_condition, should_write_header=True)
+ write_csv_for_requests(writer, columns, sort_fields, filter_condition, should_write_header=True)
diff --git a/src/registrar/views/admin_views.py b/src/registrar/views/admin_views.py
index eba8423ed..01a8157f9 100644
--- a/src/registrar/views/admin_views.py
+++ b/src/registrar/views/admin_views.py
@@ -49,8 +49,8 @@ class AnalyticsView(View):
"domain__permissions__isnull": False,
"domain__first_ready__lte": end_date_formatted,
}
- managed_domains_sliced_at_start_date = csv_export.get_sliced_domains(filter_managed_domains_start_date, True)
- managed_domains_sliced_at_end_date = csv_export.get_sliced_domains(filter_managed_domains_end_date, True)
+ managed_domains_sliced_at_start_date = csv_export.get_sliced_domains(filter_managed_domains_start_date)
+ managed_domains_sliced_at_end_date = csv_export.get_sliced_domains(filter_managed_domains_end_date)
filter_unmanaged_domains_start_date = {
"domain__permissions__isnull": True,
@@ -60,10 +60,8 @@ class AnalyticsView(View):
"domain__permissions__isnull": True,
"domain__first_ready__lte": end_date_formatted,
}
- unmanaged_domains_sliced_at_start_date = csv_export.get_sliced_domains(
- filter_unmanaged_domains_start_date, True
- )
- unmanaged_domains_sliced_at_end_date = csv_export.get_sliced_domains(filter_unmanaged_domains_end_date, True)
+ unmanaged_domains_sliced_at_start_date = csv_export.get_sliced_domains(filter_unmanaged_domains_start_date)
+ unmanaged_domains_sliced_at_end_date = csv_export.get_sliced_domains(filter_unmanaged_domains_end_date)
filter_ready_domains_start_date = {
"domain__state__in": [models.Domain.State.READY],
diff --git a/src/registrar/views/utility/mixins.py b/src/registrar/views/utility/mixins.py
index aa0c9cd6b..c7083ce48 100644
--- a/src/registrar/views/utility/mixins.py
+++ b/src/registrar/views/utility/mixins.py
@@ -307,7 +307,12 @@ class UserDeleteDomainRolePermission(PermissionsLoginMixin):
domain=domain_pk,
domain__permissions__user=self.request.user,
).exists()
- if not has_delete_permission:
+
+ user_is_analyst_or_superuser = self.request.user.has_perm(
+ "registrar.analyst_access_permission"
+ ) or self.request.user.has_perm("registrar.full_access_permission")
+
+ if not (has_delete_permission or user_is_analyst_or_superuser):
return False
# Check if more than one manager exists on the domain.
diff --git a/src/requirements.txt b/src/requirements.txt
index 1db089f5a..91f2452ca 100644
--- a/src/requirements.txt
+++ b/src/requirements.txt
@@ -1,8 +1,8 @@
-i https://pypi.python.org/simple
annotated-types==0.6.0; python_version >= '3.8'
-asgiref==3.7.2; python_version >= '3.7'
-boto3==1.34.56; python_version >= '3.8'
-botocore==1.34.56; python_version >= '3.8'
+asgiref==3.8.1; python_version >= '3.8'
+boto3==1.34.71; python_version >= '3.8'
+botocore==1.34.71; python_version >= '3.8'
cachetools==5.3.3; python_version >= '3.7'
certifi==2024.2.2; python_version >= '3.6'
cfenv==0.5.3
@@ -13,6 +13,7 @@ defusedxml==0.7.1; python_version >= '2.7' and python_version not in '3.0, 3.1,
dj-database-url==2.1.0
dj-email-url==1.0.6
django==4.2.10; python_version >= '3.8'
+django-admin-multiple-choice-list-filter==0.1.1
django-allow-cidr==0.7.1
django-auditlog==2.3.0; python_version >= '3.7'
django-cache-url==3.4.5
@@ -23,7 +24,7 @@ django-login-required-middleware==0.9.0
django-phonenumber-field[phonenumberslite]==7.3.0; python_version >= '3.8'
django-widget-tweaks==1.5.0; python_version >= '3.8'
environs[django]==11.0.0; python_version >= '3.8'
-faker==24.0.0; python_version >= '3.8'
+faker==24.4.0; python_version >= '3.8'
fred-epplib@ git+https://github.com/cisagov/epplib.git@d56d183f1664f34c40ca9716a3a9a345f0ef561c
furl==2.1.3
future==1.0.0; python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2, 3.3'
@@ -38,12 +39,12 @@ markupsafe==2.1.5; python_version >= '3.7'
marshmallow==3.21.1; python_version >= '3.8'
oic==1.6.1; python_version ~= '3.7'
orderedmultidict==1.0.1
-packaging==23.2; python_version >= '3.7'
-phonenumberslite==8.13.31
+packaging==24.0; python_version >= '3.7'
+phonenumberslite==8.13.33
psycopg2-binary==2.9.9; python_version >= '3.7'
pycparser==2.21
pycryptodomex==3.20.0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'
-pydantic==2.6.3; python_version >= '3.8'
+pydantic==2.6.4; python_version >= '3.8'
pydantic-core==2.16.3; python_version >= '3.8'
pydantic-settings==2.2.1; python_version >= '3.8'
pyjwkest==1.4.2
@@ -51,13 +52,13 @@ python-dateutil==2.9.0.post0; python_version >= '2.7' and python_version not in
python-dotenv==1.0.1; python_version >= '3.8'
pyzipper==0.3.6; python_version >= '3.4'
requests==2.31.0; python_version >= '3.7'
-s3transfer==0.10.0; python_version >= '3.8'
-setuptools==69.1.1; python_version >= '3.8'
+s3transfer==0.10.1; python_version >= '3.8'
+setuptools==69.2.0; python_version >= '3.8'
six==1.16.0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'
sqlparse==0.4.4; python_version >= '3.5'
tblib==3.0.0; python_version >= '3.8'
typing-extensions==4.10.0; python_version >= '3.8'
-urllib3==2.0.7; python_version >= '3.7'
+urllib3==2.2.1; python_version >= '3.8'
whitenoise==6.6.0; python_version >= '3.8'
zope.event==5.0; python_version >= '3.7'
zope.interface==6.2; python_version >= '3.7'