refactor: rename custom form functions to extended profile form

Author: BryanttV

openedx/core/djangoapps/user_api/accounts/api.py

@@ -171,7 +171,7 @@ def update_account_settings(requesting_user, update, username=None):
 
     old_name = _validate_name_change(user_profile, update, field_errors)
     old_language_proficiencies = _get_old_language_proficiencies_if_updating(user_profile, update)
-    custom_form = _get_and_validate_custom_form(update, user, field_errors)
+    extended_profile_form = _get_and_validate_extended_profile_form(update, user, field_errors)
 
     if field_errors:
         raise errors.AccountValidationError(field_errors)
@@ -184,7 +184,7 @@ def update_account_settings(requesting_user, update, username=None):
         _update_preferences_if_needed(update, requesting_user, user)
         _notify_language_proficiencies_update_if_needed(update, user, user_profile, old_language_proficiencies)
         _store_old_name_if_needed(old_name, user_profile, requesting_user)
-        _update_extended_profile_if_needed(update, user_profile, custom_form)
+        _update_extended_profile_if_needed(update, user_profile, extended_profile_form)
         _update_state_if_needed(update, user_profile)
 
     except PreferenceValidationError as err:
@@ -199,41 +199,39 @@ def update_account_settings(requesting_user, update, username=None):
     _send_email_change_requests_if_needed(update, user)
 
 
-def _get_and_validate_custom_form(update: dict, user, field_errors: dict) -> Optional[forms.Form]:
+def _get_and_validate_extended_profile_form(update: dict, user, field_errors: dict) -> Optional[forms.Form]:
     """
-    Validate the custom form if it exists in the update.
+    Get and validate the extended profile form if it exists in the update.
 
     Args:
         update (dict): The update data containing potential extended_profile fields
-        user (User): The user instance for whom the custom form is being validated
+        user (User): The user instance for whom the extended profile form is being validated
         field_errors (dict): Dictionary to collect field validation errors
 
     Returns:
-        Optional[forms.Form]: The validated custom form instance, or None if no custom form is needed
-
-    Raises:
-        None: All exceptions are handled internally and errors are added to field_errors
+        Optional[forms.Form]: The validated extended profile form instance,
+            or None if no extended profile form is needed
     """
     extended_profile = update.get("extended_profile")
     if not extended_profile:
         return None
 
-    custom_fields_data = _extract_custom_fields_data(extended_profile, field_errors)
-    if not custom_fields_data:
+    extended_profile_fields_data = _extract_extended_profile_fields_data(extended_profile, field_errors)
+    if not extended_profile_fields_data:
         return None
 
-    custom_form = _get_custom_form_instance(custom_fields_data, user, field_errors)
-    if not custom_form:
+    extended_profile_form = _get_extended_profile_form_instance(extended_profile_fields_data, user, field_errors)
+    if not extended_profile_form:
         return None
 
-    _validate_custom_form_and_collect_errors(custom_form, field_errors)
+    _validate_extended_profile_form_and_collect_errors(extended_profile_form, field_errors)
 
-    return custom_form
+    return extended_profile_form
 
 
-def _extract_custom_fields_data(extended_profile: Optional[list], field_errors: dict) -> dict:
+def _extract_extended_profile_fields_data(extended_profile: Optional[list], field_errors: dict) -> dict:
     """
-    Extract custom fields data from extended_profile structure.
+    Extract extended profile fields data from extended_profile structure.
 
     Args:
         extended_profile (Optional[list]): List of field data dictionaries
@@ -249,7 +247,7 @@ def _extract_custom_fields_data(extended_profile: Optional[list], field_errors:
         }
         return {}
 
-    custom_fields_data = {}
+    extended_profile_fields_data = {}
 
     for field_data in extended_profile:
         if not isinstance(field_data, dict):
@@ -264,40 +262,45 @@ def _extract_custom_fields_data(extended_profile: Optional[list], field_errors:
             continue
 
         if field_value is not None:
-            custom_fields_data[field_name] = field_value
+            extended_profile_fields_data[field_name] = field_value
 
-    return custom_fields_data
+    return extended_profile_fields_data
 
 
-def _get_custom_form_instance(
-    custom_fields_data: dict, user, field_errors: dict
+def _get_extended_profile_form_instance(
+    extended_profile_fields_data: dict, user, field_errors: dict
 ) -> Optional[forms.Form]:
     """
-    Get or create a custom form instance with the provided data.
+    Get or create an extended profile form instance.
+
+    Attempts to create a form instance using the configured `REGISTRATION_EXTENSION_FORM`.
+    If an extended profile model exists, tries to bind to existing user data or creates
+    a new instance. Handles import errors and missing configurations gracefully.
 
     Args:
-        custom_fields_data (dict): The custom fields data
-        user (User): The user instance
-        field_errors (dict): Dictionary to collect validation errors
+        extended_profile_fields_data (dict): Extended profile field data to populate the form
+        user (User): User instance to associate with the extended profile
+        field_errors (dict): Dictionary to collect validation errors if form creation fails
 
     Returns:
-        Optional[forms.Form]: The custom form instance or None if creation failed
+        Optional[forms.Form]: Extended profile form instance with user data, or None if
+        no extended profile form is configured or creation fails
     """
     try:
-        custom_model = get_extended_profile_model()
-        if not custom_model:
-            logger.info("No extended profile model configured")
-            return None
+        extended_profile_model = get_extended_profile_model()
 
-        try:
-            existing_instance = custom_model.objects.get(user=user)
-        except ObjectDoesNotExist:
-            logger.info("No existing extended profile found for user %s, creating new instance", user.username)
-            existing_instance = None
+        kwargs = {}
+        if not extended_profile_model:
+            logger.info("No extended profile model configured")
+        else:
+            try:
+                kwargs["instance"] = extended_profile_model.objects.get(user=user)
+            except ObjectDoesNotExist:
+                logger.info("No existing extended profile found for user %s, creating new instance", user.username)
 
-        custom_form = get_registration_extension_form(data=custom_fields_data, instance=existing_instance)
+        extended_profile_form = get_registration_extension_form(data=extended_profile_fields_data, **kwargs)
 
-        return custom_form
+        return extended_profile_form
 
     except ImportError as e:
         logger.warning("Extended profile model not available: %s", str(e))
@@ -311,22 +314,22 @@ def _get_custom_form_instance(
         return None
 
 
-def _validate_custom_form_and_collect_errors(custom_form: forms.Form, field_errors: dict) -> None:
+def _validate_extended_profile_form_and_collect_errors(extended_profile_form: forms.Form, field_errors: dict) -> None:
     """
-    Validate the custom form and collect any validation errors.
+    Validate the extended profile form and collect any validation errors.
 
     Args:
-        custom_form (forms.Form): The custom form to validate
+        extended_profile_form (forms.Form): The extended profile form to validate
         field_errors (dict): Dictionary to collect validation errors
     """
-    if not custom_form.is_valid():
-        logger.info("Custom form validation failed with errors: %s", custom_form.errors)
+    if not extended_profile_form.is_valid():
+        logger.info("Extended profile form validation failed with errors: %s", extended_profile_form.errors)
 
-        for field_name, field_errors_list in custom_form.errors.items():
+        for field_name, field_errors_list in extended_profile_form.errors.items():
             first_error = field_errors_list[0] if field_errors_list else "Unknown error"
 
             field_errors[field_name] = {
-                "developer_message": f"Error in custom field {field_name}: {first_error}",
+                "developer_message": f"Error in extended profile field {field_name}: {first_error}",
                 "user_message": str(first_error),
             }
 
@@ -487,53 +490,50 @@ def _notify_language_proficiencies_update_if_needed(data, user, user_profile, ol
 
 
 def _update_extended_profile_if_needed(
-    data: dict, user_profile: UserProfile, custom_form: Optional[forms.Form]
+    data: dict, user_profile: UserProfile, extended_profile_form: Optional[forms.Form]
 ) -> None:
     """
     Update the extended profile information if present in the data.
 
     This function handles two types of extended profile updates:
     1. Updates the user profile meta fields with extended_profile data
-    2. Saves the custom form data to the extended profile model if valid
+    2. Saves the extended profile form data to the extended profile model if valid
 
     Args:
         data (dict): Dictionary containing the update data, may include 'extended_profile' key
         user_profile (UserProfile): The UserProfile instance to update
-        custom_form (Optional[forms.Form]): The validated custom form containing extended profile data,
-            or None if no custom form is provided
-
-    Raises:
-        None: All exceptions are handled internally with appropriate logging
+        extended_profile_form (Optional[forms.Form]): The validated extended profile form
+            containing extended profile data, or None if no extended profile form is provided
 
     Note:
         If 'extended_profile' is present in data, the function will:
         - Extract field_name and field_value pairs from extended_profile list
         - Update the user_profile.meta dictionary with new values
         - Save the updated user_profile
 
-        If custom_form is provided and valid, the function will:
+        If extended_profile_form is provided and valid, the function will:
         - Save the form data to the extended profile model
         - Associate the model instance with the user if it's a new instance
         - Log any errors that occur during the save process
     """
-    if 'extended_profile' in data:
+    if "extended_profile" in data:
         meta = user_profile.get_meta()
-        new_extended_profile = data['extended_profile']
+        new_extended_profile = data["extended_profile"]
         for field in new_extended_profile:
-            field_name = field['field_name']
-            new_value = field['field_value']
+            field_name = field["field_name"]
+            new_value = field["field_value"]
             meta[field_name] = new_value
         user_profile.set_meta(meta)
         user_profile.save()
 
-    if custom_form and custom_form.is_valid():
+    if extended_profile_form:
         try:
-            custom_model = custom_form.save(commit=False)
-            if not hasattr(custom_model, "user") or custom_model.user is None:
-                custom_model.user = user_profile.user
-            custom_model.save()
+            extended_profile_model = extended_profile_form.save(commit=False)
+            if not hasattr(extended_profile_model, "user") or extended_profile_model.user is None:
+                extended_profile_model.user = user_profile.user
+            extended_profile_model.save()
         except Exception as e:  # pylint: disable=broad-exception-caught
-            logger.error("Error saving custom model: %s", e)
+            logger.error("Error saving extended profile model: %s", e)
 
 
 def _update_state_if_needed(data, user_profile):

openedx/core/djangoapps/user_api/accounts/serializers.py

@@ -587,9 +587,9 @@ def get_extended_profile(user_profile: UserProfile) -> list[dict[str, str]]:
     'extended_profile_fields' site configuration.
 
     The function supports two data sources:
-    1. Custom model: If REGISTRATION_EXTENSION_FORM setting points to a form with
-       a Meta.model, data is retrieved from that model using model_to_dict()
-    2. Fallback: JSON data stored in UserProfile.meta field
+    1. Custom model: If `REGISTRATION_EXTENSION_FORM` setting points to a form with
+       a `Meta.model`, data is retrieved from that model using `model_to_dict()`
+    2. Fallback: JSON data stored in `UserProfile.meta` field
 
     Args:
         user_profile (UserProfile): The user profile instance to get extended fields from.