Refactor: Update model option retrieval methods in validators and serializers for consistency

Author: Reza98Sh

src/backend/InvenTree/common/admin.py

@@ -15,7 +15,7 @@ class AttachmentAdmin(admin.ModelAdmin):
     def formfield_for_dbfield(self, db_field, request, **kwargs):
         """Provide custom choices for 'model_type' field."""
         if db_field.name == 'model_type':
-            db_field.choices = common.validators.get_model_options(
+            db_field.choices = common.validators.get_model_options_for_mixin(
                 InvenTree.models.InvenTreeAttachmentMixin
             )
 

src/backend/InvenTree/common/api.py

@@ -734,13 +734,13 @@ def validate_delete(self, queryset, request) -> None:
         - Extract all model types from the provided queryset
         - Ensure that the user has correct 'delete' permissions for each model
         """
-        from common.validators import get_model_class_from_label
+        from common.validators import resolve_model_from_label
         from users.permissions import check_user_permission
 
         model_types = queryset.values_list('model_type', flat=True).distinct()
 
         for model_type in model_types:
-            if model_class := get_model_class_from_label(
+            if model_class := resolve_model_from_label(
                 model_type, InvenTreeAttachmentMixin
             ):
                 if not check_user_permission(request.user, model_class, 'delete'):

src/backend/InvenTree/common/models.py

@@ -2186,7 +2186,7 @@ def check_permission(self, permission, user):
         """Check if the user has the required permission for this attachment."""
         from InvenTree.models import InvenTreeAttachmentMixin
 
-        model_class = common.validators.get_model_class_from_label(
+        model_class = common.validators.resolve_model_from_label(
             self.model_type, InvenTreeAttachmentMixin
         )
 

src/backend/InvenTree/common/serializers.py

@@ -616,9 +616,6 @@ class Meta:
     result = serializers.CharField()
 
 
-ALLOWED_IMAGE_CTS = common.validators.get_model_options(InvenTreeImageMixin)
-
-
 class InvenTreeImageSerializer(
     InvenTree.serializers.RemoteImageMixin, InvenTreeModelSerializer
 ):
@@ -664,8 +661,10 @@ class Meta:
     def __init__(self, *args, **kwargs):
         """Initialize the serializer and set allowed content types."""
         super().__init__(*args, **kwargs)
-        # inject your allowed list
-        self.fields['content_type'].choices = ALLOWED_IMAGE_CTS
+
+        self.fields[
+            'content_type'
+        ].choices = common.validators.get_model_options_for_mixin(InvenTreeImageMixin)
 
     def validate_content_type(self, ct_value):
         """Turn the incoming model-name string into a real ContentType instance."""
@@ -834,7 +833,9 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         if len(self.fields['model_type'].choices) == 0:
-            self.fields['model_type'].choices = common.validators.get_model_options(
+            self.fields[
+                'model_type'
+            ].choices = common.validators.get_model_options_for_mixin(
                 InvenTreeAttachmentMixin
             )
 
@@ -854,7 +855,7 @@ def __init__(self, *args, **kwargs):
     # Note: The choices are overridden at run-time on class initialization
     model_type = serializers.ChoiceField(
         label=_('Model Type'),
-        choices=common.validators.get_model_options(InvenTreeAttachmentMixin),
+        choices=common.validators.get_model_options_for_mixin(InvenTreeAttachmentMixin),
         required=True,
         allow_blank=False,
         allow_null=False,
@@ -873,7 +874,7 @@ def save(self, **kwargs):
         # Ensure that the user has permission to attach files to the specified model
         user = self.context.get('request').user
 
-        target_model_class = common.validators.get_model_class_from_label(
+        target_model_class = common.validators.resolve_model_from_label(
             model_type, InvenTreeAttachmentMixin
         )
 

src/backend/InvenTree/common/validators.py

@@ -4,41 +4,75 @@
 from typing import Union
 
 from django.core.exceptions import ValidationError
+from django.db.models import Model
 from django.utils.translation import gettext_lazy as _
 
 import common.icons
 from common.settings import get_global_setting
 
 
-def get_model_types(mixin_class):
-    """Return a list of valid attachment model choices."""
+def get_mixin_models(mixin_class: type[Model]):
+    """Return a list of Django model classes that inherit from the given mixin.
+
+    This function lazily imports the helper to avoid circular imports.
+
+    Args:
+        mixin_class: The mixin class to search for.
+
+    Returns:
+        A list of Django model classes that subclass the provided mixin.
+    """
+    # Lazy import to prevent circular dependency issues
     import InvenTree.helpers_model
 
     return list(InvenTree.helpers_model.getModelsWithMixin(mixin_class))
 
 
-def get_model_options(mixin_class):
-    """Return a list of options for models."""
-    return [
-        (model.__name__.lower(), model._meta.verbose_name)
-        for model in get_model_types(mixin_class)
-    ]
+def get_model_options_for_mixin(mixin_class: type[Model]):
+    """Build choice options for all models that inherit from a given mixin.
+
+    Each option is a tuple of:
+    - key: the lowercase model class name (e.g. 'part', 'stockitem')
+    - label: the model's verbose name for display
+
+    Args:
+        mixin_class: The mixin class used to filter models.
+
+    Returns:
+        A list of (key, label) tuples suitable for form field choices.
+    """
+    options = []
+    for model in get_mixin_models(mixin_class):
+        key = model.__name__.lower()
+        label = str(model._meta.verbose_name)
+        options.append((key, label))
+    return options
 
 
 def attachment_model_options():
     """Return a list of valid attachment model choices."""
     import InvenTree.models
 
-    return get_model_options(InvenTree.models.InvenTreeAttachmentMixin)
+    return get_model_options_for_mixin(InvenTree.models.InvenTreeAttachmentMixin)
+
 
+def resolve_model_from_label(label: str, mixin_class: type[Model]):
+    """Resolve a model class by a case-insensitive label among models inheriting a mixin.
 
-def get_model_class_from_label(label: str, mixin_class):
-    """Returns the model class matching the given label from a set of models inheriting a specific mixin."""
+    Args:
+        label: The identifier string to match (typically the model class name in lowercase).
+        mixin_class: The mixin class that candidate models must inherit from.
+
+    Returns:
+        The Django model class that matches the provided label.
+    """
     if not label:
         raise ValidationError(_('No attachment model type provided'))
 
-    for model in get_model_types(mixin_class):
-        if model.__name__.lower() == label.lower():
+    label_lc = label.lower()
+
+    for model in get_mixin_models(mixin_class):
+        if model.__name__.lower() == label_lc:
             return model
 
     raise ValidationError(_('Invalid attachment model type') + f": '{label}'")
@@ -49,7 +83,8 @@ def validate_attachment_model_type(value):
     import InvenTree.models
 
     model_names = [
-        el[0] for el in get_model_options(InvenTree.models.InvenTreeAttachmentMixin)
+        el[0]
+        for el in get_model_options_for_mixin(InvenTree.models.InvenTreeAttachmentMixin)
     ]
     if value not in model_names:
         raise ValidationError('Model type does not support attachments')
@@ -82,7 +117,7 @@ def limit_image_content_types():
     import InvenTree.models
 
     allowed_models = [
-        m[0] for m in get_model_options(InvenTree.models.InvenTreeImageMixin)
+        m[0] for m in get_model_options_for_mixin(InvenTree.models.InvenTreeImageMixin)
     ]
 
     return {'model__in': allowed_models}