Merge branch 'main' of https://github.com/cisagov/manage.get.gov into rh/2258-update-ao-to-so

docs/architecture/decisions/0026-django-waffle-library.md

@@ -0,0 +1,47 @@
+# 26. Django Waffle library for Feature Flags
+
+Date: 2024-07-06
+
+## Status
+
+Approved
+
+## Context
+
+We release finished code twice weekly, allowing features to reach users quickly. However, several upcoming features require a series of changes that will need to be done over a few sprints and should only be displayed to users once we are all done. Thus, users would see half-finished features if we followed our standard process.
+
+At the same time, some of these features should only be turned on for users upon request (and likely during user research). We would want a way for our CISA users to turn this feature on and off for people without requiring a lengthy process or code changes.
+
+This brought us to finding solutions that could fix one or both of these problems.
+
+## Considered Options
+
+**Option 1:** Environment variables
+The environment allows developers to set a true or false value to the given variable, allowing implementation over multiple sprints when new features are encapsulated with this variable. The feature shows when the variable is on (true); otherwise, it remains hidden. Environment variables are also innate to Django, making them free to use; on top of that, we already use them for other things in our code.
+
+The downside is that you would need to go to cloud.gov or use the cf CLI to see the current settings on a sandbox. This is very technical, meaning only developers would really be able to see what features were set, and we would be the only ones able to adjust them. It would also be easy to accidentally have the feature on or off without noticing. This also would not solve the problem of turning features on and off quickly for a given user group.
+
+**Option 2:** Feature branches
+Like environment variables, using feature branches would be free and allow us to iterate on developing big features over multiple sprints. We would make a feature branch that developers working on that feature would push and pull from to iterate on. This quickly brings us to the downsides of this approach.
+
+Using feature branches, we do not solve the problem of being able to turn features on and off quickly for a user group. More importantly, by working in a separate branch for more than a sprint, we easily risk having out-of-sync migrations and merge conflicts that would slow development time and cause frustration. Out-of-sync migrations can also cause technical issues on sandboxes, further contributing to development frustration.
+
+**Option 3:** Feature flags
+Feature flags are free, allowing us to implement features over multiple sprints, and some libraries can apply features based on UserGroups while even more come with an interface for non-developers to control turning feature flags on and off. Going with this decision would also entail picking the correct library or product.
+
+**Option 3a:** Feature flags with Waffle
+The Waffle feature flag library is a highly recommended Django library for handling large features. It has clear documentation on turning on feature flags for user groups, which is one of the main problems it attempts to solve. It also provides "Samples" that can turn on flags for a certain percentage of users and "Switches" that can be used to turn features on and off holistically. The reviews from those who used it were highly favorable, some even mentioning how it beat out competitors like Gargoyl. It's also compatible with Django admin, providing a quick way to add the view of the flags in Django admin so any user with admin access can modify flags for their sandbox.
+
+The repo has had new releases every year since its the creation and looks to be well maintained, with many issues on the repo referring to new feature requests. 
+
+**Option 3b:** Feature flags with Gargoyl
+Gargoyl is another feature-flag library with Django, but it is no longer maintained, and reviews say it wasn't as easy to work with as Waffle. Using it would require forking the library, and many outstanding issues indicate bugs that need fixing. The mixed reviews from those who have done this and the less robust documentation were immediately huge cons to using this as an option.
+
+**Option 3c:** Paid feature flag system with GitHub integration- LaunchDarkly
+LaunchDarkly is a Fedramped solution with excellent reviews for controlling feature flags straight from GitHub to promote any team member easily controlling feature flags. However, the big con to this was that it would be a paid solution and would take time to procure, thus slowing down our ability to start on these significant features. We shouldn't consider LaunchDarkly because taking time to procure it would negatively affect our timeline, even if the budget was eventually approved.
+
+## Decision
+Option 3a, feature flags with the Django Waffle library
+
+## Consequences
+We are now reliant on the Waffle library for feature flags. As with any library, we would need to fork it if it ever became non-maintained with critical bugs. This doesn't seem likely in the near future, but if it occurred, we could complete the forking and fix any bug within a sprint without drastically impacting our timeline.

docs/developer/management_script_helpers.md

@@ -0,0 +1,65 @@
+# Terminal Helper Functions
+`terminal_helper.py` contains utility functions to assist with common terminal and script operations. 
+This file documents what they do and provides guidance on their usage.
+
+## TerminalColors
+`TerminalColors` provides ANSI color codes as variables to style terminal output.
+
+## ScriptDataHelper
+### bulk_update_fields
+
+`bulk_update_fields` performs a memory-efficient bulk update on a Django model in batches using a Paginator.
+
+## TerminalHelper
+### log_script_run_summary
+
+`log_script_run_summary` logs a summary of a script run, including counts of updated, skipped, and failed records.
+
+### print_conditional 
+
+`print_conditional` conditionally logs a statement at a specified severity if a condition is met.
+
+### prompt_for_execution
+
+`prompt_for_execution` prompts the user to inspect a string and confirm if they wish to proceed. Returns True if proceeding, False if skipping, or exits the script.
+
+### query_yes_no
+
+`query_yes_no` prompts the user with a yes/no question and returns True for "yes" or False for "no".
+
+### query_yes_no_exit
+
+`query_yes_no_exit` is similar to `query_yes_no` but includes an "exit" option to terminate the script.
+
+## PopulateScriptTemplate
+
+`PopulateScriptTemplate` is an abstract base class that provides a template for creating generic populate scripts. It handles logging and bulk updating for repetitive scripts that update a few fields. 
+
+### **Disclaimer** 
+This template is intended as a shorthand for simple scripts. It is not recommended for complex operations. See `transfer_federal_agency.py` for a straightforward example of how to use this template.
+
+### Step-by-step usage guide
+To create a script using `PopulateScriptTemplate`:
+1. Create a new class that inherits from `PopulateScriptTemplate`
+2. Implement the `update_record` method to define how each record should be updated
+3. Optionally, override the configuration variables and helper methods as needed
+4. Call `mass_update_records` within `handle` and run the script
+
+#### Template explanation
+
+The main method provided by `PopulateScriptTemplate` is `mass_update_records`. This method loops through each valid object (specified by `filter_conditions`) and updates the fields defined in `fields_to_update` using the `update_record` method.
+
+Before updating, `mass_update_records` prompts the user to confirm the proposed changes. If the user does not proceed, the script will exit.
+
+After processing the records, `mass_update_records` performs a bulk update on the specified fields using `ScriptDataHelper.bulk_update_fields` and logs a summary of the script run using `TerminalHelper.log_script_run_summary`.
+
+#### Config options
+The class provides the following optional configuration variables:
+- `prompt_title`: The header displayed by `prompt_for_execution` when the script starts (default: "Do you wish to proceed?")
+- `display_run_summary_items_as_str`: If True, runs `str(item)` on each item when printing the run summary for prettier output (default: False)
+- `run_summary_header`: The header for the script run summary printed after the script finishes (default: None)
+
+The class also provides helper methods:
+- `get_class_name`: Returns a display-friendly class name for the terminal prompt
+- `get_failure_message`: Returns the message to display if a record fails to update
+- `should_skip_record`: Defines the condition for skipping a record (by default, no records are skipped)

docs/operations/data_migration.md

@@ -698,6 +698,33 @@ Example: `cf ssh getgov-za`
 |:-:|:-------------------------- |:----------------------------------------------------------------------------|
 | 1 | **debug**                  | Increases logging detail. Defaults to False.                                |
 
+## Transfer federal agency script
+The transfer federal agency script adds the "federal_type" field on each associated DomainRequest, and uses that to populate the "federal_type" field on each FederalAgency.
+
+**Important:** When running this script, note that data generated by our fixtures will be inaccurate (since we assign random data to them). Use real data on this script.
+Do note that there is a check on record uniqueness. If two or more records do NOT have the same value for federal_type for any given federal agency, then the record is skipped. This protects against fixtures data when loaded with real data.
+
+### Running on sandboxes
+
+#### Step 1: Login to CloudFoundry
+```cf login -a api.fr.cloud.gov --sso```
+
+#### Step 2: SSH into your environment
+```cf ssh getgov-{space}```
+
+Example: `cf ssh getgov-za`
+
+#### Step 3: Create a shell instance
+```/tmp/lifecycle/shell```
+
+#### Step 4: Running the script
+```./manage.py transfer_federal_agency_type```
+
+### Running locally
+
+#### Step 1: Running the script
+```docker-compose exec app ./manage.py transfer_federal_agency_type```
+
 ## Email current metadata report
 
 ### Running on sandboxes

src/registrar/assets/js/get-gov-admin.js

@@ -426,6 +426,10 @@ function initializeWidgetOnList(list, parentId) {
         let statusSelect = document.getElementById('id_status');
         
         function moveStatusChangelog(actionNeededReasonFormGroup, statusSelect) {
+            if (!actionNeededReasonFormGroup || !statusSelect) {
+                return;
+            }
+
             let flexContainer = actionNeededReasonFormGroup.querySelector('.flex-container');
             let statusChangelog = document.getElementById('dja-status-changelog');
 

src/registrar/management/commands/populate_verification_type.py

@@ -12,12 +12,11 @@ class Command(BaseCommand, PopulateScriptTemplate):
     def handle(self, **kwargs):
         """Loops through each valid User object and updates its verification_type value"""
         filter_condition = {"verification_type__isnull": True}
-        self.mass_populate_field(User, filter_condition, ["verification_type"])
+        self.mass_update_records(User, filter_condition, ["verification_type"])
 
-    def populate_field(self, field_to_update):
+    def update_record(self, record: User):
         """Defines how we update the verification_type field"""
-        field_to_update.set_user_verification_type()
+        record.set_user_verification_type()
         logger.info(
-            f"{TerminalColors.OKCYAN}Updating {field_to_update} => "
-            f"{field_to_update.verification_type}{TerminalColors.OKCYAN}"
+            f"{TerminalColors.OKCYAN}Updating {record} => " f"{record.verification_type}{TerminalColors.OKCYAN}"
         )

src/registrar/management/commands/transfer_federal_agency_type.py

@@ -0,0 +1,94 @@
+import logging
+from django.core.management import BaseCommand
+from registrar.management.commands.utility.terminal_helper import PopulateScriptTemplate, TerminalColors
+from registrar.models import FederalAgency, DomainInformation
+from registrar.utility.constants import BranchChoices
+
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand, PopulateScriptTemplate):
+    """
+    This command uses the PopulateScriptTemplate,
+    which provides reusable logging and bulk updating functions for mass-updating fields.
+    """
+
+    help = "Loops through each valid User object and updates its verification_type value"
+    prompt_title = "Do you wish to update all Federal Agencies?"
+
+    def handle(self, **kwargs):
+        """Loops through each valid User object and updates the value of its verification_type field"""
+
+        # These are federal agencies that we don't have any data on.
+        # Independent agencies are considered "EXECUTIVE" here.
+        self.missing_records = {
+            "Christopher Columbus Fellowship Foundation": BranchChoices.EXECUTIVE,
+            "Commission for the Preservation of America's Heritage Abroad": BranchChoices.EXECUTIVE,
+            "Commission of Fine Arts": BranchChoices.EXECUTIVE,
+            "Committee for Purchase From People Who Are Blind or Severely Disabled": BranchChoices.EXECUTIVE,
+            "DC Court Services and Offender Supervision Agency": BranchChoices.EXECUTIVE,
+            "DC Pre-trial Services": BranchChoices.EXECUTIVE,
+            "Department of Agriculture": BranchChoices.EXECUTIVE,
+            "Dwight D. Eisenhower Memorial Commission": BranchChoices.LEGISLATIVE,
+            "Farm Credit System Insurance Corporation": BranchChoices.EXECUTIVE,
+            "Federal Financial Institutions Examination Council": BranchChoices.EXECUTIVE,
+            "Federal Judiciary": BranchChoices.JUDICIAL,
+            "Institute of Peace": BranchChoices.EXECUTIVE,
+            "International Boundary and Water Commission: United States and Mexico": BranchChoices.EXECUTIVE,
+            "International Boundary Commission: United States and Canada": BranchChoices.EXECUTIVE,
+            "International Joint Commission: United States and Canada": BranchChoices.EXECUTIVE,
+            "Legislative Branch": BranchChoices.LEGISLATIVE,
+            "National Foundation on the Arts and the Humanities": BranchChoices.EXECUTIVE,
+            "Nuclear Safety Oversight Committee": BranchChoices.EXECUTIVE,
+            "Office of Compliance": BranchChoices.LEGISLATIVE,
+            "Overseas Private Investment Corporation": BranchChoices.EXECUTIVE,
+            "Public Defender Service for the District of Columbia": BranchChoices.EXECUTIVE,
+            "The Executive Office of the President": BranchChoices.EXECUTIVE,
+            "U.S. Access Board": BranchChoices.EXECUTIVE,
+            "U.S. Agency for Global Media": BranchChoices.EXECUTIVE,
+            "U.S. China Economic and Security Review Commission": BranchChoices.LEGISLATIVE,
+            "U.S. Interagency Council on Homelessness": BranchChoices.EXECUTIVE,
+            "U.S. International Trade Commission": BranchChoices.EXECUTIVE,
+            "U.S. Postal Service": BranchChoices.EXECUTIVE,
+            "U.S. Trade and Development Agency": BranchChoices.EXECUTIVE,
+            "Udall Foundation": BranchChoices.EXECUTIVE,
+            "United States Arctic Research Commission": BranchChoices.EXECUTIVE,
+            "Utah Reclamation Mitigation and Conservation Commission": BranchChoices.EXECUTIVE,
+            "Vietnam Education Foundation": BranchChoices.EXECUTIVE,
+            "Woodrow Wilson International Center for Scholars": BranchChoices.EXECUTIVE,
+            "World War I Centennial Commission": BranchChoices.EXECUTIVE,
+        }
+        # Get all existing domain requests. Select_related allows us to skip doing db queries.
+        self.all_domain_infos = DomainInformation.objects.select_related("federal_agency")
+        self.mass_update_records(
+            FederalAgency, filter_conditions={"agency__isnull": False}, fields_to_update=["federal_type"]
+        )
+
+    def update_record(self, record: FederalAgency):
+        """Defines how we update the federal_type field on each record."""
+        request = self.all_domain_infos.filter(federal_agency__agency=record.agency).first()
+        if request:
+            record.federal_type = request.federal_type
+        elif not request and record.agency in self.missing_records:
+            record.federal_type = self.missing_records.get(record.agency)
+        logger.info(f"{TerminalColors.OKCYAN}Updating {str(record)} => {record.federal_type}{TerminalColors.ENDC}")
+
+    def should_skip_record(self, record) -> bool:  # noqa
+        """Defines the conditions in which we should skip updating a record."""
+        requests = self.all_domain_infos.filter(federal_agency__agency=record.agency, federal_type__isnull=False)
+        # Check if all federal_type values are the same. Skip the record otherwise.
+        distinct_federal_types = requests.values("federal_type").distinct()
+        should_skip = distinct_federal_types.count() != 1
+        if should_skip and record.agency not in self.missing_records:
+            logger.info(
+                f"{TerminalColors.YELLOW}Skipping update for {str(record)} => count is "
+                f"{distinct_federal_types.count()} and records are {distinct_federal_types}{TerminalColors.ENDC}"
+            )
+        elif record.agency in self.missing_records:
+            logger.info(
+                f"{TerminalColors.MAGENTA}Missing data on {str(record)} - "
+                f"swapping to manual mapping{TerminalColors.ENDC}"
+            )
+            should_skip = False
+        return should_skip

src/registrar/management/commands/utility/terminal_helper.py

@@ -61,56 +61,96 @@ class ScriptDataHelper:
 
 class PopulateScriptTemplate(ABC):
     """
-    Contains an ABC for generic populate scripts
+    Contains an ABC for generic populate scripts.
+
+    This template provides reusable logging and bulk updating functions for
+    mass-updating fields.
     """
 
-    def mass_populate_field(self, sender, filter_conditions, fields_to_update):
-        """Loops through each valid "sender" object - specified by filter_conditions - and
-        updates fields defined by fields_to_update using populate_function.
+    # Optional script-global config variables. For the most part, you can leave these untouched.
+    # Defines what prompt_for_execution displays as its header when you first start the script
+    prompt_title: str = "Do you wish to proceed?"
 
-        You must define populate_field before you can use this function.
+    # The header when printing the script run summary (after the script finishes)
+    run_summary_header = None
+
+    @abstractmethod
+    def update_record(self, record):
+        """Defines how we update each field. Must be defined before using mass_update_records."""
+        raise NotImplementedError
+
+    def mass_update_records(self, object_class, filter_conditions, fields_to_update, debug=True):
+        """Loops through each valid "object_class" object - specified by filter_conditions - and
+        updates fields defined by fields_to_update using update_record.
+
+        You must define update_record before you can use this function.
         """
 
-        objects = sender.objects.filter(**filter_conditions)
+        records = object_class.objects.filter(**filter_conditions)
+        readable_class_name = self.get_class_name(object_class)
 
         # Code execution will stop here if the user prompts "N"
         TerminalHelper.prompt_for_execution(
             system_exit_on_terminate=True,
             info_to_inspect=f"""
             ==Proposed Changes==
-            Number of {sender} objects to change: {len(objects)}
+            Number of {readable_class_name} objects to change: {len(records)}
             These fields will be updated on each record: {fields_to_update}
             """,
-            prompt_title="Do you wish to patch this data?",
+            prompt_title=self.prompt_title,
         )
         logger.info("Updating...")
 
-        to_update: List[sender] = []
-        failed_to_update: List[sender] = []
-        for updated_object in objects:
+        to_update: List[object_class] = []
+        to_skip: List[object_class] = []
+        failed_to_update: List[object_class] = []
+        for record in records:
             try:
-                self.populate_field(updated_object)
-                to_update.append(updated_object)
+                if not self.should_skip_record(record):
+                    self.update_record(record)
+                    to_update.append(record)
+                else:
+                    to_skip.append(record)
             except Exception as err:
-                failed_to_update.append(updated_object)
+                fail_message = self.get_failure_message(record)
+                failed_to_update.append(record)
                 logger.error(err)
-                logger.error(f"{TerminalColors.FAIL}" f"Failed to update {updated_object}" f"{TerminalColors.ENDC}")
+                logger.error(fail_message)
 
-        # Do a bulk update on the first_ready field
-        ScriptDataHelper.bulk_update_fields(sender, to_update, fields_to_update)
+        # Do a bulk update on the desired field
+        ScriptDataHelper.bulk_update_fields(object_class, to_update, fields_to_update)
 
         # Log what happened
-        TerminalHelper.log_script_run_summary(to_update, failed_to_update, skipped=[], debug=True)
+        TerminalHelper.log_script_run_summary(
+            to_update,
+            failed_to_update,
+            to_skip,
+            debug=debug,
+            log_header=self.run_summary_header,
+            display_as_str=True,
+        )
 
-    @abstractmethod
-    def populate_field(self, field_to_update):
-        """Defines how we update each field. Must be defined before using mass_populate_field."""
-        raise NotImplementedError
+    def get_class_name(self, sender) -> str:
+        """Returns the class name that we want to display for the terminal prompt.
+        Example: DomainRequest => "Domain Request"
+        """
+        return sender._meta.verbose_name if getattr(sender, "_meta") else sender
+
+    def get_failure_message(self, record) -> str:
+        """Returns the message that we will display if a record fails to update"""
+        return f"{TerminalColors.FAIL}" f"Failed to update {record}" f"{TerminalColors.ENDC}"
+
+    def should_skip_record(self, record) -> bool:  # noqa
+        """Defines the condition in which we should skip updating a record. Override as needed."""
+        # By default - don't skip
+        return False
 
 
 class TerminalHelper:
     @staticmethod
-    def log_script_run_summary(to_update, failed_to_update, skipped, debug: bool, log_header=None):
+    def log_script_run_summary(
+        to_update, failed_to_update, skipped, debug: bool, log_header=None, display_as_str=False
+    ):
         """Prints success, failed, and skipped counts, as well as
         all affected objects."""
         update_success_count = len(to_update)
@@ -121,10 +161,14 @@ class TerminalHelper:
             log_header = "============= FINISHED ==============="
 
         # Prepare debug messages
+        if debug:
+            updated_display = [str(u) for u in to_update] if display_as_str else to_update
+            skipped_display = [str(s) for s in skipped] if display_as_str else skipped
+            failed_display = [str(f) for f in failed_to_update] if display_as_str else failed_to_update
             debug_messages = {
-            "success": (f"{TerminalColors.OKCYAN}Updated: {to_update}{TerminalColors.ENDC}\n"),
-            "skipped": (f"{TerminalColors.YELLOW}Skipped: {skipped}{TerminalColors.ENDC}\n"),
-            "failed": (f"{TerminalColors.FAIL}Failed: {failed_to_update}{TerminalColors.ENDC}\n"),
+                "success": (f"{TerminalColors.OKCYAN}Updated: {updated_display}{TerminalColors.ENDC}\n"),
+                "skipped": (f"{TerminalColors.YELLOW}Skipped: {skipped_display}{TerminalColors.ENDC}\n"),
+                "failed": (f"{TerminalColors.FAIL}Failed: {failed_display}{TerminalColors.ENDC}\n"),
             }
 
             # Print out a list of everything that was changed, if we have any changes to log.

src/registrar/models/domain_request.py

@@ -7,6 +7,7 @@ from django.conf import settings
 from django.db import models
 from django_fsm import FSMField, transition  # type: ignore
 from django.utils import timezone
+from waffle import flag_is_active
 from registrar.models.domain import Domain
 from registrar.models.federal_agency import FederalAgency
 from registrar.models.utility.generic_helper import CreateOrUpdateOrganizationTypeHelper
@@ -17,8 +18,6 @@ from .utility.time_stamped_model import TimeStampedModel
 from ..utility.email import send_templated_email, EmailSendingError
 from itertools import chain
 
-from waffle.decorators import flag_is_active
-
 logger = logging.getLogger(__name__)
 
 
@@ -675,34 +674,50 @@ class DomainRequest(TimeStampedModel):
     def _send_status_update_email(
         self, new_status, email_template, email_template_subject, send_email=True, bcc_address="", wrap_email=False
     ):
-        """Send a status update email to the submitter.
+        """Send a status update email to the creator.
 
-        The email goes to the email address that the submitter gave as their
-        contact information. If there is not submitter information, then do
+        The email goes to the email address that the creator gave as their
+        contact information. If there is not creator information, then do
         nothing.
 
+        If the waffle flag "profile_feature" is active, then this email will be sent to the
+        domain request creator rather than the submitter
+
         send_email: bool -> Used to bypass the send_templated_email function, in the event
         we just want to log that an email would have been sent, rather than actually sending one.
+
+        wrap_email: bool -> Wraps emails using `wrap_text_and_preserve_paragraphs` if any given
+        paragraph exceeds our desired max length (for prettier display).
         """
 
-        if self.submitter is None or self.submitter.email is None:
-            logger.warning(f"Cannot send {new_status} email, no submitter email address.")
+        recipient = self.creator if flag_is_active(None, "profile_feature") else self.submitter
+        if recipient is None or recipient.email is None:
+            logger.warning(
+                f"Cannot send {new_status} email, no creator email address for domain request with pk: {self.pk}."
+                f" Name: {self.requested_domain.name}"
+                if self.requested_domain
+                else ""
+            )
             return None
 
         if not send_email:
-            logger.info(f"Email was not sent. Would send {new_status} email: {self.submitter.email}")
+            logger.info(f"Email was not sent. Would send {new_status} email to: {recipient.email}")
             return None
 
         try:
             send_templated_email(
                 email_template,
                 email_template_subject,
-                self.submitter.email,
-                context={"domain_request": self},
+                recipient.email,
+                context={
+                    "domain_request": self,
+                    # This is the user that we refer to in the email
+                    "recipient": recipient,
+                },
                 bcc_address=bcc_address,
                 wrap_email=wrap_email,
             )
-            logger.info(f"The {new_status} email sent to: {self.submitter.email}")
+            logger.info(f"The {new_status} email sent to: {recipient.email}")
         except EmailSendingError:
             logger.warning("Failed to send confirmation email", exc_info=True)
 

src/registrar/templates/emails/action_needed_reasons/already_has_domains.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 We've identified an action that you’ll need to complete before we continue reviewing your .gov domain request.
 

src/registrar/templates/emails/action_needed_reasons/bad_name.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 We've identified an action that you’ll need to complete before we continue reviewing your .gov domain request.
 

src/registrar/templates/emails/action_needed_reasons/eligibility_unclear.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 We've identified an action that you’ll need to complete before we continue reviewing your .gov domain request.
 

src/registrar/templates/emails/action_needed_reasons/questionable_senior_official.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 We've identified an action that you’ll need to complete before we continue reviewing your .gov domain request.
 

src/registrar/templates/emails/domain_request_withdrawn.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 Your .gov domain request has been withdrawn and will not be reviewed by our team.
 

src/registrar/templates/emails/includes/domain_request_summary.txt

@@ -43,7 +43,7 @@ Purpose of your domain:
 {{ domain_request.purpose }}
 
 Your contact information:
-{% spaceless %}{% include "emails/includes/contact.txt" with contact=domain_request.submitter %}{% endspaceless %}
+{% spaceless %}{% include "emails/includes/contact.txt" with contact=recipient %}{% endspaceless %}
 
 Other employees from your organization:{% for other in domain_request.other_contacts.all %}
 {% spaceless %}{% include "emails/includes/contact.txt" with contact=other %}{% endspaceless %}

src/registrar/templates/emails/status_change_approved.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 Congratulations! Your .gov domain request has been approved.
 

src/registrar/templates/emails/status_change_rejected.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 Your .gov domain request has been rejected.
 

src/registrar/templates/emails/submission_confirmation.txt

@@ -1,5 +1,5 @@
 {% autoescape off %}{# In a text file, we don't want to have HTML entities escaped #}
-Hi, {{ domain_request.submitter.first_name }}.
+Hi, {{ recipient.first_name }}.
 
 We received your .gov domain request.
 

src/registrar/tests/common.py

@@ -858,6 +858,7 @@ def completed_domain_request(  # noqa
     is_election_board=False,
     organization_type=None,
     federal_agency=None,
+    federal_type=None,
     action_needed_reason=None,
 ):
     """A completed domain request."""
@@ -923,6 +924,9 @@ def completed_domain_request(  # noqa
     if organization_type:
         domain_request_kwargs["organization_type"] = organization_type
 
+    if federal_type:
+        domain_request_kwargs["federal_type"] = federal_type
+
     if action_needed_reason:
         domain_request_kwargs["action_needed_reason"] = action_needed_reason
 

src/registrar/tests/test_admin.py

@@ -944,7 +944,7 @@ class TestDomainRequestAdminForm(TestCase):
             self.assertIn("rejection_reason", form.errors)
 
             rejection_reason = form.errors.get("rejection_reason")
-            self.assertEqual(rejection_reason, ["A rejection reason is required."])
+            self.assertEqual(rejection_reason, ["A reason is required for this status."])
 
     def test_form_choices_when_no_instance(self):
         with less_console_noise():
@@ -1929,7 +1929,7 @@ class TestDomainRequestAdmin(MockEppLib):
 
                 messages.error.assert_called_once_with(
                     request,
-                    "A rejection reason is required.",
+                    "A reason is required for this status.",
                 )
 
             domain_request.refresh_from_db()

src/registrar/tests/test_management_scripts.py

@@ -2,6 +2,7 @@ import copy
 from datetime import date, datetime, time
 from django.core.management import call_command
 from django.test import TestCase, override_settings
+from registrar.utility.constants import BranchChoices
 from django.utils import timezone
 from django.utils.module_loading import import_string
 import logging
@@ -1112,3 +1113,115 @@ class TestImportTables(TestCase):
 
             # Check that logger.error was called with the correct message
             mock_logger.error.assert_called_once_with("Zip file tmp/exported_tables.zip does not exist.")
+
+
+class TestTransferFederalAgencyType(TestCase):
+    """Tests for the transfer_federal_agency_type script"""
+
+    def setUp(self):
+        """Creates a fake domain object"""
+        super().setUp()
+
+        self.amtrak, _ = FederalAgency.objects.get_or_create(agency="AMTRAK")
+        self.legislative_branch, _ = FederalAgency.objects.get_or_create(agency="Legislative Branch")
+        self.library_of_congress, _ = FederalAgency.objects.get_or_create(agency="Library of Congress")
+        self.gov_admin, _ = FederalAgency.objects.get_or_create(agency="gov Administration")
+
+        self.domain_request_1 = completed_domain_request(
+            name="testgov.gov",
+            federal_agency=self.amtrak,
+            federal_type=BranchChoices.EXECUTIVE,
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+        )
+        self.domain_request_2 = completed_domain_request(
+            name="cheesefactory.gov",
+            federal_agency=self.legislative_branch,
+            federal_type=BranchChoices.LEGISLATIVE,
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+        )
+        self.domain_request_3 = completed_domain_request(
+            name="meowardslaw.gov",
+            federal_agency=self.library_of_congress,
+            federal_type=BranchChoices.JUDICIAL,
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+        )
+
+        # Duplicate fields with invalid data - we expect to skip updating these
+        self.domain_request_4 = completed_domain_request(
+            name="baddata.gov",
+            federal_agency=self.gov_admin,
+            federal_type=BranchChoices.EXECUTIVE,
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+        )
+        self.domain_request_5 = completed_domain_request(
+            name="worsedata.gov",
+            federal_agency=self.gov_admin,
+            federal_type=BranchChoices.JUDICIAL,
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+        )
+
+        self.domain_request_1.approve()
+        self.domain_request_2.approve()
+        self.domain_request_3.approve()
+        self.domain_request_4.approve()
+        self.domain_request_5.approve()
+
+    def tearDown(self):
+        """Deletes all DB objects related to migrations"""
+        super().tearDown()
+
+        # Delete domains and related information
+        Domain.objects.all().delete()
+        DomainInformation.objects.all().delete()
+        DomainRequest.objects.all().delete()
+        User.objects.all().delete()
+        Contact.objects.all().delete()
+        Website.objects.all().delete()
+        FederalAgency.objects.all().delete()
+
+    def run_transfer_federal_agency_type(self):
+        """
+        This method executes the transfer_federal_agency_type command.
+
+        The 'call_command' function from Django's management framework is then used to
+        execute the populate_first_ready command with the specified arguments.
+        """
+        with less_console_noise():
+            with patch(
+                "registrar.management.commands.utility.terminal_helper.TerminalHelper.query_yes_no_exit",  # noqa
+                return_value=True,
+            ):
+                call_command("transfer_federal_agency_type")
+
+    @less_console_noise_decorator
+    def test_transfer_federal_agency_type_script(self):
+        """
+        Tests that the transfer_federal_agency_type script updates what we expect, and skips what we expect
+        """
+
+        # Before proceeding, make sure we don't have any data contamination
+        tested_agencies = [
+            self.amtrak,
+            self.legislative_branch,
+            self.library_of_congress,
+            self.gov_admin,
+        ]
+        for agency in tested_agencies:
+            self.assertEqual(agency.federal_type, None)
+
+        # Run the script
+        self.run_transfer_federal_agency_type()
+
+        # Refresh the local db instance to reflect changes
+        self.amtrak.refresh_from_db()
+        self.legislative_branch.refresh_from_db()
+        self.library_of_congress.refresh_from_db()
+        self.gov_admin.refresh_from_db()
+
+        # Test the values that we expect to be updated
+        self.assertEqual(self.amtrak.federal_type, BranchChoices.EXECUTIVE)
+        self.assertEqual(self.legislative_branch.federal_type, BranchChoices.LEGISLATIVE)
+        self.assertEqual(self.library_of_congress.federal_type, BranchChoices.JUDICIAL)
+
+        # We don't expect this field to be updated (as it has duplicate data)
+        self.assertEqual(self.gov_admin.federal_type, None)

src/registrar/tests/test_models.py

@@ -25,6 +25,7 @@ from registrar.utility.constants import BranchChoices
 
 from .common import MockSESClient, less_console_noise, completed_domain_request, set_domain_request_investigators
 from django_fsm import TransitionNotAllowed
+from waffle.testutils import override_flag
 
 
 # Test comment for push -- will remove
@@ -33,29 +34,44 @@ from django_fsm import TransitionNotAllowed
 @boto3_mocking.patching
 class TestDomainRequest(TestCase):
     def setUp(self):
+
+        self.dummy_user, _ = Contact.objects.get_or_create(
+            email="mayor@igorville.com", first_name="Hello", last_name="World"
+        )
+        self.dummy_user_2, _ = User.objects.get_or_create(
+            username="intern@igorville.com", email="intern@igorville.com", first_name="Lava", last_name="World"
+        )
         self.started_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.STARTED, name="started.gov"
+            status=DomainRequest.DomainRequestStatus.STARTED,
+            name="started.gov",
         )
         self.submitted_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.SUBMITTED, name="submitted.gov"
+            status=DomainRequest.DomainRequestStatus.SUBMITTED,
+            name="submitted.gov",
         )
         self.in_review_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.IN_REVIEW, name="in-review.gov"
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+            name="in-review.gov",
         )
         self.action_needed_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.ACTION_NEEDED, name="action-needed.gov"
+            status=DomainRequest.DomainRequestStatus.ACTION_NEEDED,
+            name="action-needed.gov",
         )
         self.approved_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.APPROVED, name="approved.gov"
+            status=DomainRequest.DomainRequestStatus.APPROVED,
+            name="approved.gov",
         )
         self.withdrawn_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.WITHDRAWN, name="withdrawn.gov"
+            status=DomainRequest.DomainRequestStatus.WITHDRAWN,
+            name="withdrawn.gov",
         )
         self.rejected_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.REJECTED, name="rejected.gov"
+            status=DomainRequest.DomainRequestStatus.REJECTED,
+            name="rejected.gov",
         )
         self.ineligible_domain_request = completed_domain_request(
-            status=DomainRequest.DomainRequestStatus.INELIGIBLE, name="ineligible.gov"
+            status=DomainRequest.DomainRequestStatus.INELIGIBLE,
+            name="ineligible.gov",
         )
 
         # Store all domain request statuses in a variable for ease of use
@@ -199,7 +215,9 @@ class TestDomainRequest(TestCase):
                     domain_request.submit()
             self.assertEqual(domain_request.status, domain_request.DomainRequestStatus.SUBMITTED)
 
-    def check_email_sent(self, domain_request, msg, action, expected_count):
+    def check_email_sent(
+        self, domain_request, msg, action, expected_count, expected_content=None, expected_email="mayor@igorville.com"
+    ):
         """Check if an email was sent after performing an action."""
 
         with self.subTest(msg=msg, action=action):
@@ -213,19 +231,35 @@ class TestDomainRequest(TestCase):
             sent_emails = [
                 email
                 for email in MockSESClient.EMAILS_SENT
-                if "mayor@igorville.gov" in email["kwargs"]["Destination"]["ToAddresses"]
+                if expected_email in email["kwargs"]["Destination"]["ToAddresses"]
             ]
             self.assertEqual(len(sent_emails), expected_count)
 
+            if expected_content:
+                email_content = sent_emails[0]["kwargs"]["Content"]["Simple"]["Body"]["Text"]["Data"]
+                self.assertIn(expected_content, email_content)
+
+    @override_flag("profile_feature", active=False)
     def test_submit_from_started_sends_email(self):
         msg = "Create a domain request and submit it and see if email was sent."
-        domain_request = completed_domain_request()
-        self.check_email_sent(domain_request, msg, "submit", 1)
+        domain_request = completed_domain_request(submitter=self.dummy_user, user=self.dummy_user_2)
+        self.check_email_sent(domain_request, msg, "submit", 1, expected_content="Hello")
+
+    @override_flag("profile_feature", active=True)
+    def test_submit_from_started_sends_email_to_creator(self):
+        """Tests if, when the profile feature flag is on, we send an email to the creator"""
+        msg = "Create a domain request and submit it and see if email was sent when the feature flag is on."
+        domain_request = completed_domain_request(submitter=self.dummy_user, user=self.dummy_user_2)
+        self.check_email_sent(
+            domain_request, msg, "submit", 1, expected_content="Lava", expected_email="intern@igorville.com"
+        )
 
     def test_submit_from_withdrawn_sends_email(self):
         msg = "Create a withdrawn domain request and submit it and see if email was sent."
-        domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.WITHDRAWN)
-        self.check_email_sent(domain_request, msg, "submit", 1)
+        domain_request = completed_domain_request(
+            status=DomainRequest.DomainRequestStatus.WITHDRAWN, submitter=self.dummy_user
+        )
+        self.check_email_sent(domain_request, msg, "submit", 1, expected_content="Hello")
 
     def test_submit_from_action_needed_does_not_send_email(self):
         msg = "Create a domain request with ACTION_NEEDED status and submit it, check if email was not sent."
@@ -239,18 +273,24 @@ class TestDomainRequest(TestCase):
 
     def test_approve_sends_email(self):
         msg = "Create a domain request and approve it and see if email was sent."
-        domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
-        self.check_email_sent(domain_request, msg, "approve", 1)
+        domain_request = completed_domain_request(
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW, submitter=self.dummy_user
+        )
+        self.check_email_sent(domain_request, msg, "approve", 1, expected_content="Hello")
 
     def test_withdraw_sends_email(self):
         msg = "Create a domain request and withdraw it and see if email was sent."
-        domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
-        self.check_email_sent(domain_request, msg, "withdraw", 1)
+        domain_request = completed_domain_request(
+            status=DomainRequest.DomainRequestStatus.IN_REVIEW, submitter=self.dummy_user
+        )
+        self.check_email_sent(domain_request, msg, "withdraw", 1, expected_content="Hello")
 
     def test_reject_sends_email(self):
         msg = "Create a domain request and reject it and see if email was sent."
-        domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.APPROVED)
-        self.check_email_sent(domain_request, msg, "reject", 1)
+        domain_request = completed_domain_request(
+            status=DomainRequest.DomainRequestStatus.APPROVED, submitter=self.dummy_user
+        )
+        self.check_email_sent(domain_request, msg, "reject", 1, expected_content="Hello")
 
     def test_reject_with_prejudice_does_not_send_email(self):
         msg = "Create a domain request and reject it with prejudice and see if email was sent."

src/registrar/utility/errors.py

@@ -101,7 +101,7 @@ class FSMDomainRequestError(Exception):
         FSMErrorCodes.NO_INVESTIGATOR: ("Investigator is required for this status."),
         FSMErrorCodes.INVESTIGATOR_NOT_STAFF: ("Investigator is not a staff user."),
         FSMErrorCodes.INVESTIGATOR_NOT_SUBMITTER: ("Only the assigned investigator can make this change."),
-        FSMErrorCodes.NO_REJECTION_REASON: ("A rejection reason is required."),
+        FSMErrorCodes.NO_REJECTION_REASON: ("A reason is required for this status."),
         FSMErrorCodes.NO_ACTION_NEEDED_REASON: ("A reason is required for this status."),
     }