Add settings to allow changing the Model/Manager/QuerySet/OneToOneField/ForeignKey

- Useful in case one is using django-auto-prefetch, for instance

Author: jacklinke

src/django_tenant_options/app_settings.py

@@ -10,31 +10,121 @@
     }
 
 """
-import logging
 
-from django.core.exceptions import ImproperlyConfigured
+import logging
 
+from django_tenant_options.form_fields import (  # noqa: F401
+    OptionsModelMultipleChoiceField,
+)
 
-logger = logging.getLogger(__name__)
 
 try:
+    import_error = None
     from django.conf import settings
+    from django.core.exceptions import ImproperlyConfigured
+    from django.db import models
 except ImproperlyConfigured as e:
-    logger.error("Settings could not be imported: %s", e)
+    import_error = "Settings could not be imported: %s", e
     settings = None  # pylint: disable=C0103
 except ImportError as e:
-    logger.error("Django could not be imported. Settings cannot be loaded: %s", e)
+    import_error = "Django could not be imported. Settings cannot be loaded: %s", e
     settings = None  # pylint: disable=C0103
-from django.db import models
 
-from django_tenant_options.form_fields import (  # noqa: F401
-    OptionsModelMultipleChoiceField,
-)
+logger = logging.getLogger(__name__)
+
+if import_error:
+    logger.error(import_error)
+
+
+class ModelClassConfig:
+    """Configuration class for model base classes."""
+
+    def __init__(self):
+        self._model_class = models.Model
+        self._manager_class = models.Manager
+        self._queryset_class = models.QuerySet
+        self._foreignkey_class = models.ForeignKey
+        self._onetoonefield_class = models.OneToOneField
+
+    @property
+    def model_class(self):
+        """The base class to use for all django-tenant-options models."""
+        return self._model_class
+
+    @model_class.setter
+    def model_class(self, cls):
+        """Set the base class to use for all django-tenant-options models."""
+        self._model_class = cls
 
+    @property
+    def manager_class(self):
+        """The base class to use for all django-tenant-options model managers."""
+        return self._manager_class
+
+    @manager_class.setter
+    def manager_class(self, cls):
+        """Set the base class to use for all django-tenant-options model managers."""
+        self._manager_class = cls
+
+    @property
+    def queryset_class(self):
+        """The base class to use for all django-tenant-options model querysets."""
+        return self._queryset_class
+
+    @queryset_class.setter
+    def queryset_class(self, cls):
+        """Set the base class to use for all django-tenant-options model querysets."""
+        self._queryset_class = cls
+
+    @property
+    def foreignkey_class(self):
+        """The base class to use for all django-tenant-options foreign keys."""
+        return self._foreignkey_class
+
+    @foreignkey_class.setter
+    def foreignkey_class(self, cls):
+        """Set the base class to use for all django-tenant-options foreign keys."""
+        self._foreignkey_class = cls
+
+    @property
+    def onetoonefield_class(self):
+        """The base class to use for all django-tenant-options one-to-one fields."""
+        return self._onetoonefield_class
+
+    @onetoonefield_class.setter
+    def onetoonefield_class(self, cls):
+        """Set the base class to use for all django-tenant-options one-to-one fields."""
+        self._onetoonefield_class = cls
+
+
+# Global config instance for django-tenant-options models
+model_config = ModelClassConfig()
 
 _DJANGO_TENANT_OPTIONS = getattr(settings, "DJANGO_TENANT_OPTIONS", {})
 """dict: The settings for the django-tenant-options app."""
 
+# Base class settings
+MODEL_CLASS = _DJANGO_TENANT_OPTIONS.get("MODEL_CLASS", models.Model)
+"""The base Model class to use. Defaults to django.db.models.Model."""
+
+MANAGER_CLASS = _DJANGO_TENANT_OPTIONS.get("MANAGER_CLASS", models.Manager)
+"""The base Manager class to use. Defaults to django.db.models.Manager."""
+
+QUERYSET_CLASS = _DJANGO_TENANT_OPTIONS.get("QUERYSET_CLASS", models.QuerySet)
+"""The base QuerySet class to use. Defaults to django.db.models.QuerySet."""
+
+FOREIGNKEY_CLASS = _DJANGO_TENANT_OPTIONS.get("FOREIGNKEY_CLASS", models.ForeignKey)
+"""The ForeignKey field class to use. Defaults to django.db.models.ForeignKey."""
+
+ONETOONEFIELD_CLASS = _DJANGO_TENANT_OPTIONS.get("ONETOONEFIELD_CLASS", models.OneToOneField)
+"""The OneToOneField field class to use. Defaults to django.db.models.OneToOneField."""
+
+model_config.model_class = MODEL_CLASS
+model_config.manager_class = MANAGER_CLASS
+model_config.queryset_class = QUERYSET_CLASS
+model_config.foreignkey_class = FOREIGNKEY_CLASS
+model_config.onetoonefield_class = ONETOONEFIELD_CLASS
+
 TENANT_MODEL = _DJANGO_TENANT_OPTIONS.get("TENANT_MODEL", "django_tenant_options.Tenant")
 """str: The model to use for the tenant."""
 

src/django_tenant_options/models.py

@@ -25,6 +25,7 @@
 from django_tenant_options.app_settings import TENANT_MODEL_RELATED_NAME
 from django_tenant_options.app_settings import TENANT_MODEL_RELATED_QUERY_NAME
 from django_tenant_options.app_settings import TENANT_ON_DELETE
+from django_tenant_options.app_settings import model_config
 from django_tenant_options.choices import OptionType
 from django_tenant_options.exceptions import IncorrectSubclassError
 from django_tenant_options.exceptions import InvalidDefaultOptionError
@@ -103,7 +104,9 @@ def __new__(cls, name, bases, attrs, **kwargs):
                     fields["blank"] = True
                     fields["null"] = True
 
-                ConcreteModel.add_to_class("tenant", models.ForeignKey(ConcreteModel.tenant_model, **fields))
+                ConcreteModel.add_to_class(
+                    "tenant", model_config.foreignkey_class(ConcreteModel.tenant_model, **fields)
+                )
 
         return model
 
@@ -190,7 +193,7 @@ def __new__(cls, name, bases, attrs, **kwargs):
 
                 ConcreteSelectionModel.add_to_class(
                     "option",
-                    models.ForeignKey(
+                    model_config.foreignkey_class(
                         ConcreteSelectionModel.option_model,
                         on_delete=ConcreteSelectionModel.option_on_delete,
                         related_name=ConcreteSelectionModel.option_model_related_name,
@@ -203,7 +206,7 @@ def __new__(cls, name, bases, attrs, **kwargs):
         return model
 
 
-class OptionQuerySet(models.QuerySet):
+class OptionQuerySet(model_config.queryset_class):
     """Custom QuerySet for Option models.
 
     Subclass this QuerySet to provide additional functionality for your concrete Option model.
@@ -284,7 +287,7 @@ def delete(self, override=False):
         return self.update(deleted=timezone.now())
 
 
-class OptionManager(models.Manager):
+class OptionManager(model_config.manager_class):
     """Manager for Option models.
 
     Provides methods for creating default options and filtering out deleted options.
@@ -327,7 +330,7 @@ def _update_or_create_default_option(self, item_name: str, options_dict: dict =
                         f"You specified {key} = {value} for {item_name=}."
                     )
 
-        obj, created = self.model.objects.update_or_create(
+        self.model.objects.update_or_create(
             name=item_name,
             option_type=option_type,
             defaults={"deleted": None},  # Undelete the option if it was previously deleted
@@ -366,7 +369,7 @@ def _update_default_options(self) -> dict:
                 self.model.objects._update_or_create_default_option(name, options_dict)
                 updated_options[name] = options_dict
             except Exception as e:
-                logger.error(f"Error updating option {name}: {e}")
+                logger.error("Error updating option %s: %s", name, e)
 
         # Soft delete options no longer in defaults
         existing_options = self.model.objects.filter(
@@ -402,7 +405,7 @@ def get_condition_argument_name():
     }
 
 
-class AbstractOption(models.Model, metaclass=OptionModelBase):
+class AbstractOption(model_config.model_class, metaclass=OptionModelBase):
     """Abstract model for defining all available Options.
 
     Options which are provided by default through model configuration may be Mandatory or Optional.
@@ -438,7 +441,7 @@ class AbstractOption(models.Model, metaclass=OptionModelBase):
     )
 
     objects = OptionManager.from_queryset(OptionQuerySet)()
-    unscoped = models.Manager()
+    unscoped = model_config.manager_class()
 
     class Meta:  # pylint: disable=R0903
         """Meta options for AbstractOption.
@@ -546,7 +549,7 @@ def save(self, *args, **kwargs):
         super().save(*args, **kwargs)
 
 
-class SelectionQuerySet(models.QuerySet):
+class SelectionQuerySet(model_config.queryset_class):
     """Custom QuerySet for Selection models.
 
     Subclass this QuerySet to provide additional functionality for your concrete Selection model.
@@ -575,7 +578,7 @@ def delete(self, override=False):
         return self.update(deleted=timezone.now())
 
 
-class SelectionManager(models.Manager):
+class SelectionManager(model_config.manager_class):
     """Custom Manager for Selection models.
 
     Subclass this manager to provide additional functionality for your concrete Selection model.
@@ -621,7 +624,7 @@ def selected_options_for_tenant(self, tenant, include_deleted=False):
             return None
 
 
-class AbstractSelection(models.Model, metaclass=SelectionModelBase):
+class AbstractSelection(model_config.model_class, metaclass=SelectionModelBase):
     """Identifies all selected Options for a given tenant, which it's users can then choose from.
 
     A single tenant can select multiple Options. This model is a through model for the ManyToManyField
@@ -645,7 +648,7 @@ class AbstractSelection(models.Model, metaclass=SelectionModelBase):
     )
 
     objects = SelectionManager.from_queryset(SelectionQuerySet)()
-    unscoped = models.Manager()
+    unscoped = model_config.manager_class()
 
     class Meta:  # pylint: disable=R0903
         """Meta options for AbstractSelection.
@@ -668,8 +671,8 @@ def clean(self):
         """Ensure that the selected option is available to the tenant."""
         if self.option.tenant and self.option.tenant != self.tenant:  # pylint: disable=E1101
             raise ValueError(
-                "The selected custom option '%s' belongs to tenant '%s', and is not available to tenant '%s'."
-                % (self.option.name, self.option.tenant, self.tenant)
+                f"The selected custom option '{self.option.name}' belongs to tenant '{self.option.tenant}', "
+                f"and is not available to tenant '{self.tenant}'."
             )
 
         super().clean()
@@ -689,9 +692,8 @@ def delete(self, using=None, keep_parents=False, override=False):
         """
         if override:
             return super().delete(using=using, keep_parents=keep_parents)
-        else:
-            self.deleted = timezone.now()
-            self.save()
+        self.deleted = timezone.now()
+        self.save()
 
     @classmethod
     def get_concrete_subclasses(cls) -> list: