| Domain name |
- Date created |
+ Date submitted |
Status |
Action |
@@ -110,7 +112,13 @@
{{ application.requested_domain.name|default:"New domain request" }}
|
- {{ application.created_at|date }} |
+
+ {% if application.submission_date %}
+ {{ application.submission_date|date }}
+ {% else %}
+ Not submitted
+ {% endif %}
+ |
{{ application.get_status_display }} |
{% if application.status == "started" or application.status == "action needed" or application.status == "withdrawn" %}
diff --git a/src/registrar/templates/includes/domain_dates.html b/src/registrar/templates/includes/domain_dates.html
new file mode 100644
index 000000000..c05e202e1
--- /dev/null
+++ b/src/registrar/templates/includes/domain_dates.html
@@ -0,0 +1,12 @@
+{% if domain.expiration_date or domain.created_at %}
+
+ {% if domain.expiration_date %}
+ Expires:
+ {{ domain.expiration_date|date }}
+ {% if domain.is_expired %} (expired){% endif %}
+
+ {% endif %}
+ {% if domain.created_at %}
+ Date created: {{ domain.created_at|date }}{% endif %}
+
+{% endif %}
diff --git a/src/registrar/tests/test_admin.py b/src/registrar/tests/test_admin.py
index 29944396e..9c9da29cc 100644
--- a/src/registrar/tests/test_admin.py
+++ b/src/registrar/tests/test_admin.py
@@ -15,13 +15,7 @@ from registrar.admin import (
ContactAdmin,
UserDomainRoleAdmin,
)
-from registrar.models import (
- Domain,
- DomainApplication,
- DomainInformation,
- User,
- DomainInvitation,
-)
+from registrar.models import Domain, DomainApplication, DomainInformation, User, DomainInvitation, Contact, Website
from registrar.models.user_domain_role import UserDomainRole
from .common import (
completed_application,
@@ -323,6 +317,7 @@ class TestDomainApplicationAdmin(MockEppLib):
self.admin = DomainApplicationAdmin(model=DomainApplication, admin_site=self.site)
self.superuser = create_superuser()
self.staffuser = create_user()
+ self.client = Client(HTTP_HOST="localhost:8080")
def test_short_org_name_in_applications_list(self):
"""
@@ -637,6 +632,7 @@ class TestDomainApplicationAdmin(MockEppLib):
"no_other_contacts_rationale",
"anything_else",
"is_policy_acknowledged",
+ "submission_date",
"current_websites",
"other_contacts",
"alternative_domains",
@@ -860,12 +856,224 @@ class TestDomainApplicationAdmin(MockEppLib):
with self.assertRaises(DomainInformation.DoesNotExist):
domain_information.refresh_from_db()
+ def test_has_correct_filters(self):
+ """
+ This test verifies that DomainApplicationAdmin has the correct filters set up.
+
+ It retrieves the current list of filters from DomainApplicationAdmin
+ and checks that it matches the expected list of filters.
+ """
+ request = self.factory.get("/")
+ request.user = self.superuser
+
+ # Grab the current list of table filters
+ readonly_fields = self.admin.get_list_filter(request)
+ expected_fields = ("status", "organization_type", DomainApplicationAdmin.InvestigatorFilter)
+
+ self.assertEqual(readonly_fields, expected_fields)
+
+ def test_table_sorted_alphabetically(self):
+ """
+ This test verifies that the DomainApplicationAdmin table is sorted alphabetically
+ by the 'requested_domain__name' field.
+
+ It creates a list of DomainApplication instances in a non-alphabetical order,
+ then retrieves the queryset from the DomainApplicationAdmin and checks
+ that it matches the expected queryset,
+ which is sorted alphabetically by the 'requested_domain__name' field.
+ """
+ # Creates a list of DomainApplications in scrambled order
+ multiple_unalphabetical_domain_objects("application")
+
+ request = self.factory.get("/")
+ request.user = self.superuser
+
+ # Get the expected list of alphabetically sorted DomainApplications
+ expected_order = DomainApplication.objects.order_by("requested_domain__name")
+
+ # Get the returned queryset
+ queryset = self.admin.get_queryset(request)
+
+ # Check the order
+ self.assertEqual(
+ list(queryset),
+ list(expected_order),
+ )
+
+ def test_displays_investigator_filter(self):
+ """
+ This test verifies that the investigator filter in the admin interface for
+ the DomainApplication model displays correctly.
+
+ It creates two DomainApplication instances, each with a different investigator.
+ It then simulates a staff user logging in and applying the investigator filter
+ on the DomainApplication admin page.
+
+ We then test if the page displays the filter we expect, but we do not test
+ if we get back the correct response in the table. This is to isolate if
+ the filter displays correctly, when the filter isn't filtering correctly.
+ """
+
+ # Create a mock DomainApplication object, with a fake investigator
+ application: DomainApplication = generic_domain_object("application", "SomeGuy")
+ investigator_user = User.objects.filter(username=application.investigator.username).get()
+ investigator_user.is_staff = True
+ investigator_user.save()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domainapplication/",
+ {
+ "investigator__id__exact": investigator_user.id,
+ },
+ follow=True,
+ )
+
+ # Then, test if the filter actually exists
+ self.assertIn("filters", response.context)
+
+ # Assert the content of filters and search_query
+ filters = response.context["filters"]
+
+ self.assertEqual(
+ filters,
+ [
+ {
+ "parameter_name": "investigator",
+ "parameter_value": "SomeGuy first_name:investigator SomeGuy last_name:investigator",
+ },
+ ],
+ )
+
+ def test_investigator_filter_filters_correctly(self):
+ """
+ This test verifies that the investigator filter in the admin interface for
+ the DomainApplication model works correctly.
+
+ It creates two DomainApplication instances, each with a different investigator.
+ It then simulates a staff user logging in and applying the investigator filter
+ on the DomainApplication admin page.
+
+ It then verifies that it was applied correctly.
+ The test checks that the response contains the expected DomainApplication pbjects
+ in the table.
+ """
+
+ # Create a mock DomainApplication object, with a fake investigator
+ application: DomainApplication = generic_domain_object("application", "SomeGuy")
+ investigator_user = User.objects.filter(username=application.investigator.username).get()
+ investigator_user.is_staff = True
+ investigator_user.save()
+
+ # Create a second mock DomainApplication object, to test filtering
+ application: DomainApplication = generic_domain_object("application", "BadGuy")
+ another_user = User.objects.filter(username=application.investigator.username).get()
+ another_user.is_staff = True
+ another_user.save()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domainapplication/",
+ {
+ "investigator__id__exact": investigator_user.id,
+ },
+ follow=True,
+ )
+
+ expected_name = "SomeGuy first_name:investigator SomeGuy last_name:investigator"
+ # We expect to see this four times, two of them are from the html for the filter,
+ # and the other two are the html from the list entry in the table.
+ self.assertContains(response, expected_name, count=4)
+
+ # Check that we don't also get the thing we aren't filtering for.
+ # We expect to see this two times in the filter
+ unexpected_name = "BadGuy first_name:investigator BadGuy last_name:investigator"
+ self.assertContains(response, unexpected_name, count=2)
+
+ def test_investigator_dropdown_displays_only_staff(self):
+ """
+ This test verifies that the dropdown for the 'investigator' field in the DomainApplicationAdmin
+ interface only displays users who are marked as staff.
+
+ It creates two DomainApplication instances, one with an investigator
+ who is a staff user and another with an investigator who is not a staff user.
+
+ It then retrieves the queryset for the 'investigator' dropdown from DomainApplicationAdmin
+ and checks that it matches the expected queryset, which only includes staff users.
+ """
+ # Create a mock DomainApplication object, with a fake investigator
+ application: DomainApplication = generic_domain_object("application", "SomeGuy")
+ investigator_user = User.objects.filter(username=application.investigator.username).get()
+ investigator_user.is_staff = True
+ investigator_user.save()
+
+ # Create a mock DomainApplication object, with a user that is not staff
+ application_2: DomainApplication = generic_domain_object("application", "SomeOtherGuy")
+ investigator_user_2 = User.objects.filter(username=application_2.investigator.username).get()
+ investigator_user_2.is_staff = False
+ investigator_user_2.save()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+
+ request = self.factory.post("/admin/registrar/domainapplication/{}/change/".format(application.pk))
+
+ # Get the actual field from the model's meta information
+ investigator_field = DomainApplication._meta.get_field("investigator")
+
+ # We should only be displaying staff users, in alphabetical order
+ expected_dropdown = list(User.objects.filter(is_staff=True))
+ current_dropdown = list(self.admin.formfield_for_foreignkey(investigator_field, request).queryset)
+
+ self.assertEqual(expected_dropdown, current_dropdown)
+
+ # Non staff users should not be in the list
+ self.assertNotIn(application_2, current_dropdown)
+
+ def test_investigator_list_is_alphabetically_sorted(self):
+ """
+ This test verifies that filter list for the 'investigator'
+ is displayed alphabetically
+ """
+ # Create a mock DomainApplication object, with a fake investigator
+ application: DomainApplication = generic_domain_object("application", "SomeGuy")
+ investigator_user = User.objects.filter(username=application.investigator.username).get()
+ investigator_user.is_staff = True
+ investigator_user.save()
+
+ application_2: DomainApplication = generic_domain_object("application", "AGuy")
+ investigator_user_2 = User.objects.filter(username=application_2.investigator.username).get()
+ investigator_user_2.first_name = "AGuy"
+ investigator_user_2.is_staff = True
+ investigator_user_2.save()
+
+ application_3: DomainApplication = generic_domain_object("application", "FinalGuy")
+ investigator_user_3 = User.objects.filter(username=application_3.investigator.username).get()
+ investigator_user_3.first_name = "FinalGuy"
+ investigator_user_3.is_staff = True
+ investigator_user_3.save()
+
+ p = "userpass"
+ self.client.login(username="staffuser", password=p)
+ request = RequestFactory().get("/")
+
+ expected_list = list(User.objects.filter(is_staff=True).order_by("first_name", "last_name", "email"))
+
+ # Get the actual sorted list of investigators from the lookups method
+ actual_list = [item for _, item in self.admin.InvestigatorFilter.lookups(self, request, self.admin)]
+
+ self.assertEqual(expected_list, actual_list)
+
def tearDown(self):
super().tearDown()
Domain.objects.all().delete()
DomainInformation.objects.all().delete()
DomainApplication.objects.all().delete()
User.objects.all().delete()
+ Contact.objects.all().delete()
+ Website.objects.all().delete()
class DomainInvitationAdminTest(TestCase):
diff --git a/src/registrar/tests/test_models_domain.py b/src/registrar/tests/test_models_domain.py
index b76e2000c..461d87661 100644
--- a/src/registrar/tests/test_models_domain.py
+++ b/src/registrar/tests/test_models_domain.py
@@ -1966,6 +1966,9 @@ class TestExpirationDate(MockEppLib):
"""
super().setUp()
# for the tests, need a domain in the ready state
+ # mock data for self.domain includes the following dates:
+ # cr_date=datetime.datetime(2023, 5, 25, 19, 45, 35)
+ # ex_date=datetime.date(2023, 5, 25)
self.domain, _ = Domain.objects.get_or_create(name="fake.gov", state=Domain.State.READY)
# for the test, need a domain that will raise an exception
self.domain_w_error, _ = Domain.objects.get_or_create(name="fake-error.gov", state=Domain.State.READY)
@@ -1991,6 +1994,23 @@ class TestExpirationDate(MockEppLib):
with self.assertRaises(RegistryError):
self.domain_w_error.renew_domain()
+ def test_is_expired(self):
+ """assert that is_expired returns true for expiration_date in past"""
+ # force fetch_cache to be called
+ self.domain.statuses
+ self.assertTrue(self.domain.is_expired)
+
+ def test_is_not_expired(self):
+ """assert that is_expired returns false for expiration in future"""
+ # to do this, need to mock value returned from timezone.now
+ # set now to 2023-01-01
+ mocked_datetime = datetime.datetime(2023, 1, 1, 12, 0, 0)
+ # force fetch_cache which sets the expiration date to 2023-05-25
+ self.domain.statuses
+
+ with patch("registrar.models.domain.timezone.now", return_value=mocked_datetime):
+ self.assertFalse(self.domain.is_expired())
+
def test_expiration_date_updated_on_info_domain_call(self):
"""assert that expiration date in db is updated on info domain call"""
# force fetch_cache to be called
@@ -1999,6 +2019,36 @@ class TestExpirationDate(MockEppLib):
self.assertEquals(self.domain.expiration_date, test_date)
+class TestCreationDate(MockEppLib):
+ """Created_at in domain model is updated from EPP"""
+
+ def setUp(self):
+ """
+ Domain exists in registry
+ """
+ super().setUp()
+ # for the tests, need a domain with a creation date
+ self.domain, _ = Domain.objects.get_or_create(name="fake.gov", state=Domain.State.READY)
+ # creation_date returned from mockDataInfoDomain with creation date:
+ # cr_date=datetime.datetime(2023, 5, 25, 19, 45, 35)
+ self.creation_date = datetime.datetime(2023, 5, 25, 19, 45, 35)
+
+ def tearDown(self):
+ Domain.objects.all().delete()
+ super().tearDown()
+
+ def test_creation_date_setter_not_implemented(self):
+ """assert that the setter for creation date is not implemented and will raise error"""
+ with self.assertRaises(NotImplementedError):
+ self.domain.creation_date = datetime.date.today()
+
+ def test_creation_date_updated_on_info_domain_call(self):
+ """assert that creation date in db is updated on info domain call"""
+ # force fetch_cache to be called
+ self.domain.statuses
+ self.assertEquals(self.domain.created_at, self.creation_date)
+
+
class TestAnalystClientHold(MockEppLib):
"""Rule: Analysts may suspend or restore a domain by using client hold"""
diff --git a/src/registrar/tests/test_views.py b/src/registrar/tests/test_views.py
index e69ab3dfd..bc661d119 100644
--- a/src/registrar/tests/test_views.py
+++ b/src/registrar/tests/test_views.py
@@ -6,7 +6,6 @@ from django.test import Client, TestCase
from django.urls import reverse
from django.contrib.auth import get_user_model
from .common import MockEppLib, completed_application, create_user # type: ignore
-
from django_webtest import WebTest # type: ignore
import boto3_mocking # type: ignore
@@ -100,7 +99,7 @@ class LoggedInTests(TestWithUser):
response = self.client.get("/")
# count = 2 because it is also in screenreader content
self.assertContains(response, "igorville.gov", count=2)
- self.assertContains(response, "DNS needed")
+ self.assertContains(response, "Expired")
# clean up
role.delete()
@@ -1331,6 +1330,12 @@ class TestDomainDetail(TestDomainOverview):
class TestDomainManagers(TestDomainOverview):
+ def tearDown(self):
+ """Ensure that the user has its original permissions"""
+ super().tearDown()
+ self.user.is_staff = False
+ self.user.save()
+
def test_domain_managers(self):
response = self.client.get(reverse("domain-users", kwargs={"pk": self.domain.id}))
self.assertContains(response, "Domain managers")
@@ -1457,6 +1462,189 @@ class TestDomainManagers(TestDomainOverview):
Content=ANY,
)
+ @boto3_mocking.patching
+ def test_domain_invitation_email_has_email_as_requester_non_existent(self):
+ """Inviting a non existent user sends them an email, with email as the name."""
+ # make sure there is no user with this email
+ email_address = "mayor@igorville.gov"
+ User.objects.filter(email=email_address).delete()
+
+ self.domain_information, _ = DomainInformation.objects.get_or_create(creator=self.user, domain=self.domain)
+
+ mock_client = MagicMock()
+ mock_client_instance = mock_client.return_value
+
+ with boto3_mocking.clients.handler_for("sesv2", mock_client):
+ add_page = self.app.get(reverse("domain-users-add", kwargs={"pk": self.domain.id}))
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ add_page.form["email"] = email_address
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+ add_page.form.submit()
+
+ # check the mock instance to see if `send_email` was called right
+ mock_client_instance.send_email.assert_called_once_with(
+ FromEmailAddress=settings.DEFAULT_FROM_EMAIL,
+ Destination={"ToAddresses": [email_address]},
+ Content=ANY,
+ )
+
+ # Check the arguments passed to send_email method
+ _, kwargs = mock_client_instance.send_email.call_args
+
+ # Extract the email content, and check that the message is as we expect
+ email_content = kwargs["Content"]["Simple"]["Body"]["Text"]["Data"]
+ self.assertIn("info@example.com", email_content)
+
+ # Check that the requesters first/last name do not exist
+ self.assertNotIn("First", email_content)
+ self.assertNotIn("Last", email_content)
+ self.assertNotIn("First Last", email_content)
+
+ @boto3_mocking.patching
+ def test_domain_invitation_email_has_email_as_requester(self):
+ """Inviting a user sends them an email, with email as the name."""
+ # Create a fake user object
+ email_address = "mayor@igorville.gov"
+ User.objects.get_or_create(email=email_address, username="fakeuser@fakeymail.com")
+
+ self.domain_information, _ = DomainInformation.objects.get_or_create(creator=self.user, domain=self.domain)
+
+ mock_client = MagicMock()
+ mock_client_instance = mock_client.return_value
+
+ with boto3_mocking.clients.handler_for("sesv2", mock_client):
+ add_page = self.app.get(reverse("domain-users-add", kwargs={"pk": self.domain.id}))
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ add_page.form["email"] = email_address
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+ add_page.form.submit()
+
+ # check the mock instance to see if `send_email` was called right
+ mock_client_instance.send_email.assert_called_once_with(
+ FromEmailAddress=settings.DEFAULT_FROM_EMAIL,
+ Destination={"ToAddresses": [email_address]},
+ Content=ANY,
+ )
+
+ # Check the arguments passed to send_email method
+ _, kwargs = mock_client_instance.send_email.call_args
+
+ # Extract the email content, and check that the message is as we expect
+ email_content = kwargs["Content"]["Simple"]["Body"]["Text"]["Data"]
+ self.assertIn("info@example.com", email_content)
+
+ # Check that the requesters first/last name do not exist
+ self.assertNotIn("First", email_content)
+ self.assertNotIn("Last", email_content)
+ self.assertNotIn("First Last", email_content)
+
+ @boto3_mocking.patching
+ def test_domain_invitation_email_has_email_as_requester_staff(self):
+ """Inviting a user sends them an email, with email as the name."""
+ # Create a fake user object
+ email_address = "mayor@igorville.gov"
+ User.objects.get_or_create(email=email_address, username="fakeuser@fakeymail.com")
+
+ # Make sure the user is staff
+ self.user.is_staff = True
+ self.user.save()
+
+ self.domain_information, _ = DomainInformation.objects.get_or_create(creator=self.user, domain=self.domain)
+
+ mock_client = MagicMock()
+ mock_client_instance = mock_client.return_value
+
+ with boto3_mocking.clients.handler_for("sesv2", mock_client):
+ add_page = self.app.get(reverse("domain-users-add", kwargs={"pk": self.domain.id}))
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ add_page.form["email"] = email_address
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+ add_page.form.submit()
+
+ # check the mock instance to see if `send_email` was called right
+ mock_client_instance.send_email.assert_called_once_with(
+ FromEmailAddress=settings.DEFAULT_FROM_EMAIL,
+ Destination={"ToAddresses": [email_address]},
+ Content=ANY,
+ )
+
+ # Check the arguments passed to send_email method
+ _, kwargs = mock_client_instance.send_email.call_args
+
+ # Extract the email content, and check that the message is as we expect
+ email_content = kwargs["Content"]["Simple"]["Body"]["Text"]["Data"]
+ self.assertIn("help@get.gov", email_content)
+
+ # Check that the requesters first/last name do not exist
+ self.assertNotIn("First", email_content)
+ self.assertNotIn("Last", email_content)
+ self.assertNotIn("First Last", email_content)
+
+ @boto3_mocking.patching
+ def test_domain_invitation_email_displays_error_non_existent(self):
+ """Inviting a non existent user sends them an email, with email as the name."""
+ # make sure there is no user with this email
+ email_address = "mayor@igorville.gov"
+ User.objects.filter(email=email_address).delete()
+
+ # Give the user who is sending the email an invalid email address
+ self.user.email = ""
+ self.user.save()
+
+ self.domain_information, _ = DomainInformation.objects.get_or_create(creator=self.user, domain=self.domain)
+
+ mock_client = MagicMock()
+
+ mock_error_message = MagicMock()
+ with boto3_mocking.clients.handler_for("sesv2", mock_client):
+ with patch("django.contrib.messages.error") as mock_error_message:
+ add_page = self.app.get(reverse("domain-users-add", kwargs={"pk": self.domain.id}))
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ add_page.form["email"] = email_address
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+ add_page.form.submit().follow()
+
+ expected_message_content = "Can't send invitation email. No email is associated with your account."
+
+ # Grab the message content
+ returned_error_message = mock_error_message.call_args[0][1]
+
+ # Check that the message content is what we expect
+ self.assertEqual(expected_message_content, returned_error_message)
+
+ @boto3_mocking.patching
+ def test_domain_invitation_email_displays_error(self):
+ """When the requesting user has no email, an error is displayed"""
+ # make sure there is no user with this email
+ # Create a fake user object
+ email_address = "mayor@igorville.gov"
+ User.objects.get_or_create(email=email_address, username="fakeuser@fakeymail.com")
+
+ # Give the user who is sending the email an invalid email address
+ self.user.email = ""
+ self.user.save()
+
+ self.domain_information, _ = DomainInformation.objects.get_or_create(creator=self.user, domain=self.domain)
+
+ mock_client = MagicMock()
+
+ mock_error_message = MagicMock()
+ with boto3_mocking.clients.handler_for("sesv2", mock_client):
+ with patch("django.contrib.messages.error") as mock_error_message:
+ add_page = self.app.get(reverse("domain-users-add", kwargs={"pk": self.domain.id}))
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ add_page.form["email"] = email_address
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+ add_page.form.submit().follow()
+
+ expected_message_content = "Can't send invitation email. No email is associated with your account."
+
+ # Grab the message content
+ returned_error_message = mock_error_message.call_args[0][1]
+
+ # Check that the message content is what we expect
+ self.assertEqual(expected_message_content, returned_error_message)
+
def test_domain_invitation_cancel(self):
"""Posting to the delete view deletes an invitation."""
email_address = "mayor@igorville.gov"
diff --git a/src/registrar/views/domain.py b/src/registrar/views/domain.py
index 5ec4433f7..59b206993 100644
--- a/src/registrar/views/domain.py
+++ b/src/registrar/views/domain.py
@@ -17,7 +17,6 @@ from django.views.generic.edit import FormMixin
from registrar.models import (
Domain,
- DomainInformation,
DomainInvitation,
User,
UserDomainRole,
@@ -644,21 +643,27 @@ class DomainAddUserView(DomainFormBaseView):
"""Get an absolute URL for this domain."""
return self.request.build_absolute_uri(reverse("domain", kwargs={"pk": self.object.id}))
- def _send_domain_invitation_email(self, email: str, add_success=True):
+ def _send_domain_invitation_email(self, email: str, requester: User, add_success=True):
"""Performs the sending of the domain invitation email,
does not make a domain information object
email: string- email to send to
add_success: bool- default True indicates:
adding a success message to the view if the email sending succeeds"""
- # created a new invitation in the database, so send an email
- domainInfoResults = DomainInformation.objects.filter(domain=self.object)
- domainInfo = domainInfoResults.first()
- first = ""
- last = ""
- if domainInfo is not None:
- first = domainInfo.creator.first_name
- last = domainInfo.creator.last_name
- full_name = f"{first} {last}"
+
+ # Set a default email address to send to for staff
+ requester_email = "help@get.gov"
+
+ # Check if the email requester has a valid email address
+ if not requester.is_staff and requester.email is not None and requester.email.strip() != "":
+ requester_email = requester.email
+ elif not requester.is_staff:
+ messages.error(self.request, "Can't send invitation email. No email is associated with your account.")
+ logger.error(
+ f"Can't send email to '{email}' on domain '{self.object}'."
+ f"No email exists for the requester '{requester.username}'.",
+ exc_info=True,
+ )
+ return None
try:
send_templated_email(
@@ -668,7 +673,7 @@ class DomainAddUserView(DomainFormBaseView):
context={
"domain_url": self._domain_abs_url(),
"domain": self.object,
- "full_name": full_name,
+ "requester_email": requester_email,
},
)
except EmailSendingError:
@@ -683,7 +688,7 @@ class DomainAddUserView(DomainFormBaseView):
if add_success:
messages.success(self.request, f"Invited {email} to this domain.")
- def _make_invitation(self, email_address: str):
+ def _make_invitation(self, email_address: str, requester: User):
"""Make a Domain invitation for this email and redirect with a message."""
invitation, created = DomainInvitation.objects.get_or_create(email=email_address, domain=self.object)
if not created:
@@ -693,21 +698,22 @@ class DomainAddUserView(DomainFormBaseView):
f"{email_address} has already been invited to this domain.",
)
else:
- self._send_domain_invitation_email(email=email_address)
+ self._send_domain_invitation_email(email=email_address, requester=requester)
return redirect(self.get_success_url())
def form_valid(self, form):
"""Add the specified user on this domain."""
requested_email = form.cleaned_data["email"]
+ requester = self.request.user
# look up a user with that email
try:
requested_user = User.objects.get(email=requested_email)
except User.DoesNotExist:
# no matching user, go make an invitation
- return self._make_invitation(requested_email)
+ return self._make_invitation(requested_email, requester)
else:
# if user already exists then just send an email
- self._send_domain_invitation_email(requested_email, add_success=False)
+ self._send_domain_invitation_email(requested_email, requester, add_success=False)
try:
UserDomainRole.objects.create(
diff --git a/src/registrar/views/index.py b/src/registrar/views/index.py
index b203694ff..9605c723d 100644
--- a/src/registrar/views/index.py
+++ b/src/registrar/views/index.py
@@ -1,7 +1,6 @@
-from django.db.models import F
from django.shortcuts import render
-from registrar.models import DomainApplication
+from registrar.models import DomainApplication, Domain, UserDomainRole
def index(request):
@@ -14,12 +13,9 @@ def index(request):
# the active applications table
context["domain_applications"] = applications.exclude(status="approved")
- domains = request.user.permissions.values(
- "role",
- pk=F("domain__id"),
- name=F("domain__name"),
- created_time=F("domain__created_at"),
- state=F("domain__state"),
- )
+ user_domain_roles = UserDomainRole.objects.filter(user=request.user)
+ domain_ids = user_domain_roles.values_list("domain_id", flat=True)
+ domains = Domain.objects.filter(id__in=domain_ids)
+
context["domains"] = domains
return render(request, "home.html", context)
|