modified userportfoliopermissions and portfolioinvitation admin forms

src/registrar/admin.py

@@ -192,126 +192,158 @@ class MyUserAdminForm(UserChangeForm):
             )
 
 
-class UserPortfolioPermissionsForm(forms.ModelForm):
+class PortfolioPermissionsForm(forms.ModelForm):
+    """
+    Form for managing portfolio permissions in Django admin. This form class is used
+    for both UserPortfolioPermission and PortfolioInvitation models.
+
+    Allows selecting a portfolio, assigning a role, and managing specific permissions
+    related to requests, domains, and members.
+    """
+
+    # Define available permissions for requests, domains, and members
     REQUEST_PERMISSIONS = [
         UserPortfolioPermissionChoices.VIEW_ALL_REQUESTS,
         UserPortfolioPermissionChoices.EDIT_REQUESTS,
     ]
-    
+
     DOMAIN_PERMISSIONS = [
         UserPortfolioPermissionChoices.VIEW_ALL_DOMAINS,
         UserPortfolioPermissionChoices.VIEW_MANAGED_DOMAINS,
     ]
-    
+
     MEMBER_PERMISSIONS = [
         UserPortfolioPermissionChoices.VIEW_MEMBERS,
     ]
 
-    user = forms.ModelChoiceField(
-        queryset=models.User.objects.all(),
-        label="User"
-    )
-
-    portfolio = forms.ModelChoiceField(
-        queryset=models.Portfolio.objects.all(),
-        label="Portfolio"
-    )
+    # Dropdown to select a portfolio
+    portfolio = forms.ModelChoiceField(queryset=models.Portfolio.objects.all(), label="Portfolio")
 
+    # Dropdown for selecting the user role (e.g., Admin or Basic)
     role = forms.ChoiceField(
         choices=UserPortfolioRoleChoices.choices,
         required=True,
         widget=forms.Select(attrs={"class": "admin-dropdown"}),
-        label="Member access"
+        label="Member access",
     )
 
+    # Dropdown for selecting request permissions, with a default "No access" option
     request_permissions = forms.ChoiceField(
-        choices=[(perm.value, perm.label) for perm in REQUEST_PERMISSIONS],
+        choices=[(None, "No access")] + [(perm.value, perm.label) for perm in REQUEST_PERMISSIONS],
         required=False,
         widget=forms.Select(attrs={"class": "admin-dropdown"}),
-        label="Domain requests"
+        label="Domain requests",
     )
 
+    # Dropdown for selecting domain permissions
     domain_permissions = forms.ChoiceField(
         choices=[(perm.value, perm.label) for perm in DOMAIN_PERMISSIONS],
         required=False,
         widget=forms.Select(attrs={"class": "admin-dropdown"}),
-        label="Domains"
+        label="Domains",
     )
 
+    # Dropdown for selecting member permissions, with a default "No access" option
     member_permissions = forms.ChoiceField(
-        choices=[(perm.value, perm.label) for perm in MEMBER_PERMISSIONS],
+        choices=[(None, "No access")] + [(perm.value, perm.label) for perm in MEMBER_PERMISSIONS],
         required=False,
         widget=forms.Select(attrs={"class": "admin-dropdown"}),
-        label="Members"
+        label="Members",
     )
 
-    class Meta:
-        model = models.UserPortfolioPermission
-        fields = ["user", "portfolio", "role", "domain_permissions", "request_permissions", "member_permissions"]
-
     def __init__(self, *args, **kwargs):
+        """
+        Initialize the form and set default values based on the existing instance.
+        """
         super().__init__(*args, **kwargs)
 
-        logger.debug("Initializing form")
-        
-        # Populate roles
+        # If an instance exists, populate the form fields with existing data
         if self.instance and self.instance.pk:
+            # Set the initial value for the role field
             if self.instance.roles:
-                logger.debug(f"Setting role: {self.instance.roles[0]}")
-                self.fields["role"].initial = self.instance.roles[0]  # Assuming single role per user
+                self.fields["role"].initial = self.instance.roles[0]  # Assuming a single role per user
 
+            # Set the initial values for permissions based on the instance data
             if self.instance.additional_permissions:
-                logger.debug(f"Existing permissions: {self.instance.additional_permissions}")
                 for perm in self.instance.additional_permissions:
-                    logger.debug(f"Processing permission: {perm}")
                     if perm in self.REQUEST_PERMISSIONS:
-                        logger.debug("Assigning request permission")
                         self.fields["request_permissions"].initial = perm
                     elif perm in self.DOMAIN_PERMISSIONS:
-                        logger.debug("Assigning domain permission")
                         self.fields["domain_permissions"].initial = perm
                     elif perm in self.MEMBER_PERMISSIONS:
-                        logger.debug("Assigning member permission")
                         self.fields["member_permissions"].initial = perm
 
     def clean(self):
+        """
+        Custom validation and processing of form data before saving.
+        """
         cleaned_data = super().clean()
-        
-        self.instance.roles = [cleaned_data.get("role")] if cleaned_data.get("role") else []
-        logger.debug(f"Cleaned roles: {self.instance.roles}")
 
+        # Store the selected role as a list (assuming single role assignment)
+        self.instance.roles = [cleaned_data.get("role")] if cleaned_data.get("role") else []
+
+        # If the selected role is "organization_member," store additional permissions
         if self.instance.roles == [UserPortfolioRoleChoices.ORGANIZATION_MEMBER]:
             self.instance.additional_permissions = list(
-                filter(None, [
-                    cleaned_data.get("request_permissions"),
-                    cleaned_data.get("domain_permissions"),
-                    cleaned_data.get("member_permissions"),
-                ])
+                filter(
+                    None,
+                    [
+                        cleaned_data.get("request_permissions"),
+                        cleaned_data.get("domain_permissions"),
+                        cleaned_data.get("member_permissions"),
+                    ],
+                )
             )
         else:
+            # If the user is an admin, clear any additional permissions
             self.instance.additional_permissions = []
-        
-        logger.debug(f"Final saved permissions: {self.instance.additional_permissions}")
 
         return cleaned_data
 
 
-class PortfolioInvitationAdminForm(UserChangeForm):
-    """This form utilizes the custom widget for its class's ManyToMany UIs."""
+class UserPortfolioPermissionsForm(PortfolioPermissionsForm):
+    """
+    Form for managing user portfolio permissions in Django admin.
+
+    Extends PortfolioPermissionsForm to include a user field, allowing administrators
+    to assign roles and permissions to specific users within a portfolio.
+    """
+
+    # Dropdown to select a user from the database
+    user = forms.ModelChoiceField(queryset=models.User.objects.all(), label="User")
 
     class Meta:
-        model = models.PortfolioInvitation
-        fields = "__all__"
-        widgets = {
-            "roles": FilteredSelectMultipleArrayWidget(
-                "roles", is_stacked=False, choices=UserPortfolioRoleChoices.choices
-            ),
-            "additional_permissions": FilteredSelectMultipleArrayWidget(
-                "additional_permissions",
-                is_stacked=False,
-                choices=UserPortfolioPermissionChoices.choices,
-            ),
-        }
+        """
+        Meta class defining the model and fields to be used in the form.
+        """
+
+        model = models.UserPortfolioPermission  # Uses the UserPortfolioPermission model
+        fields = ["user", "portfolio", "role", "domain_permissions", "request_permissions", "member_permissions"]
+
+
+class PortfolioInvitationForm(PortfolioPermissionsForm):
+    """
+    Form for sending portfolio invitations in Django admin.
+
+    Extends PortfolioPermissionsForm to include an email field for inviting users,
+    allowing them to be assigned a role and permissions within a portfolio before they join.
+    """
+
+    class Meta:
+        """
+        Meta class defining the model and fields to be used in the form.
+        """
+
+        model = models.PortfolioInvitation  # Uses the PortfolioInvitation model
+        fields = [
+            "email",
+            "portfolio",
+            "role",
+            "domain_permissions",
+            "request_permissions",
+            "member_permissions",
+            "status",
+        ]
 
 
 class DomainInformationAdminForm(forms.ModelForm):
@@ -1721,7 +1753,7 @@ class DomainInvitationAdmin(BaseInvitationAdmin):
 class PortfolioInvitationAdmin(BaseInvitationAdmin):
     """Custom portfolio invitation admin class."""
 
-    form = PortfolioInvitationAdminForm
+    form = PortfolioInvitationForm
 
     class Meta:
         model = models.PortfolioInvitation