Merge pull request #764 from awesto/drafts/refactor-perform-model-checks

Drafts/refactor perform model checks

shop/apps.py

@@ -22,6 +22,5 @@ def ready(self):
 
         # perform some sanity checks
         ForeignKeyBuilder.check_for_pending_mappings()
-        ForeignKeyBuilder.perform_model_checks()
 
         cms_tags.register.tags['page_attribute'] = PageAttribute

shop/deferred.py

@@ -194,24 +194,13 @@ def perform_meta_model_check(cls, Model):
         implementation of the just created type.
         """
 
-    @classmethod
-    def perform_model_check(cls):
-        """
-        Hook for each materialized class inheriting from ForeignKeyBuilder, to perform model checks.
-        """
-
     @classmethod
     def check_for_pending_mappings(cls):
         if cls._pending_mappings:
             msg = "Deferred foreign key '{0}.{1}' has not been mapped"
             pm = cls._pending_mappings
             raise ImproperlyConfigured(msg.format(pm[0][0].__name__, pm[0][1]))
 
-    @classmethod
-    def perform_model_checks(cls):
-        for model in cls._materialized_models.values():
-            model.perform_model_check()
-
 
 class PolymorphicForeignKeyBuilder(ForeignKeyBuilder, PolymorphicModelBase):
     """

shop/models/cart.py

@@ -4,9 +4,8 @@
 from six import with_metaclass
 import warnings
 from collections import OrderedDict
-
+from django.core import checks
 from django.db import models
-from django.core.exceptions import ImproperlyConfigured
 from django.utils.translation import ugettext_lazy as _
 
 from shop import deferred
@@ -101,17 +100,20 @@ class Meta:
         verbose_name_plural = _("Cart items")
 
     @classmethod
-    def perform_model_check(cls):
-        allowed_types = ['IntegerField', 'DecimalField', 'FloatField']
+    def check(cls, **kwargs):
+        errors = super(BaseCartItem, cls).check(**kwargs)
+        allowed_types = ['IntegerField', 'SmallIntegerField', 'PositiveIntegerField',
+                         'PositiveSmallIntegerField', 'DecimalField', 'FloatField']
         for field in cls._meta.fields:
             if field.attname == 'quantity':
-                if not field.get_internal_type() in allowed_types:
-                    msg = "Field `{}.quantity` must be of one of the types: {}."
-                    raise ImproperlyConfigured(msg.format(cls.__name__, allowed_types))
+                if field.get_internal_type() not in allowed_types:
+                    msg = "Class `{}.quantity` must be of one of the types: {}."
+                    errors.append(checks.Error(msg.format(cls.__name__, allowed_types)))
                 break
         else:
             msg = "Class `{}` must implement a field named `quantity`."
-            raise ImproperlyConfigured(msg.format(cls.__name__))
+            errors.append(checks.Error(msg.format(cls.__name__)))
+        return errors
 
     def __init__(self, *args, **kwargs):
         # reduce the given fields to what the model actually can consume

shop/models/defaults/cart_item.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-from django.core.validators import MinValueValidator
-from django.db.models import IntegerField
+from django.db.models import PositiveIntegerField
 from shop.models import cart
 
 
 class CartItem(cart.BaseCartItem):
     """Default materialized model for CartItem"""
-    quantity = IntegerField(validators=[MinValueValidator(0)])
+    quantity = PositiveIntegerField()

shop/models/defaults/order_item.py

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-from django.db import models
+from django.db.models import PositiveIntegerField
 from django.utils.translation import ugettext_lazy as _, pgettext_lazy
 from shop.models import order
 
 
 class OrderItem(order.BaseOrderItem):
     """Default materialized model for OrderItem"""
-    quantity = models.IntegerField(_("Ordered quantity"))
+    quantity = PositiveIntegerField(_("Ordered quantity"))
 
     class Meta:
         verbose_name = pgettext_lazy('order_models', "Ordered Item")

shop/models/delivery.py

@@ -2,8 +2,8 @@
 from __future__ import unicode_literals
 
 from six import with_metaclass
+from django.core import checks
 from django.db import models
-from django.core.exceptions import ImproperlyConfigured
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.translation import ugettext_lazy as _
 from shop import deferred
@@ -55,13 +55,15 @@ def __str__(self):
         return _("Delivery ID: {}").format(self.id)
 
     @classmethod
-    def perform_model_check(cls):
+    def check(cls, **kwargs):
+        errors = super(BaseDelivery, cls).check(**kwargs)
         for field in OrderItemModel._meta.fields:
             if field.attname == 'canceled' and field.get_internal_type() == 'BooleanField':
                 break
         else:
              msg = "Class `{}` must implement a `BooleanField` named `canceled`, if used in combination with a Delivery model."
-             raise ImproperlyConfigured(msg.format(OrderItemModel.__name__))
+             errors.append(checks.Error(msg.format(OrderItemModel.__name__)))
+        return errors
 
     def clean(self):
         if self.order._fsm_requested_transition == ('status', 'ship_goods') and not self.shipped_at:
@@ -106,21 +108,23 @@ class Meta:
         verbose_name_plural = _("Deliver items")
 
     @classmethod
-    def perform_model_check(cls):
+    def check(cls, **kwargs):
+        errors = super(BaseDeliveryItem, cls).check(**kwargs)
         for order_field in OrderItemModel._meta.fields:
             if order_field.attname == 'quantity':
                 break
         else:
             msg = "Class `{}` must implement a field named `quantity`."
-            raise ImproperlyConfigured(msg.format(OrderItemModel.__name__))
+            errors.append(checks.Error(msg.format(OrderItemModel.__name__)))
         for deliver_field in OrderItemModel._meta.fields:
             if deliver_field.attname == 'quantity':
                 break
         else:
             msg = "Class `{}` must implement a field named `quantity`."
-            raise ImproperlyConfigured(msg.format(cls.__name__))
+            errors.append(checks.Error(msg.format(cls.__name__)))
         if order_field.get_internal_type() != deliver_field.get_internal_type():
             msg = "Field `{}.quantity` must be of one same type `{}.quantity`."
-            raise ImproperlyConfigured(msg.format(cls.__name__, OrderItemModel.__name__))
+            errors.append(checks.Error(msg.format(cls.__name__, OrderItemModel.__name__)))
+        return errors
 
 DeliveryItemModel = deferred.MaterializedModel(BaseDeliveryItem)

shop/models/order.py

@@ -4,6 +4,7 @@
 from decimal import Decimal
 import logging
 from six import with_metaclass
+from django.core import checks
 from django.core.exceptions import ImproperlyConfigured
 from django.db import models, transaction
 from django.db.models.aggregates import Sum
@@ -516,22 +517,24 @@ def __str__(self):
         return self.product_name
 
     @classmethod
-    def perform_model_check(cls):
+    def check(cls, **kwargs):
+        errors = super(BaseOrderItem, cls).check(**kwargs)
         for cart_field in CartItemModel._meta.fields:
             if cart_field.attname == 'quantity':
                 break
         else:
             msg = "Class `{}` must implement a field named `quantity`."
-            raise ImproperlyConfigured(msg.format(CartItemModel.__name__))
-        for order_field in OrderItemModel._meta.fields:
-            if order_field.attname == 'quantity':
+            errors.append(checks.Error(msg.format(CartItemModel.__name__)))
+        for field in cls._meta.fields:
+            if field.attname == 'quantity':
+                if field.get_internal_type() != cart_field.get_internal_type():
+                    msg = "Field `{}.quantity` must be of same type as `{}.quantity`."
+                    errors.append(checks.Error(msg.format(cls.__name__, CartItemModel.__name__)))
                 break
         else:
             msg = "Class `{}` must implement a field named `quantity`."
-            raise ImproperlyConfigured(msg.format(OrderItemModel.__name__))
-        if order_field.get_internal_type() != cart_field.get_internal_type():
-            msg = "Field `{}.quantity` must be of one same type `{}.quantity`."
-            raise ImproperlyConfigured(msg.format(CartItemModel.__name__, OrderItemModel.__name__))
+            errors.append(checks.Error(msg.format(cls.__name__)))
+        return errors
 
     @property
     def unit_price(self):

shop/models/product.py

@@ -6,6 +6,7 @@
 from functools import reduce
 import operator
 from cms import __version__ as CMS_VERSION
+from django.core import checks
 from django.db import models
 from django.utils import six
 from django.utils.encoding import force_text
@@ -177,12 +178,14 @@ def get_weight(self):
         return 0
 
     @classmethod
-    def perform_model_check(cls):
+    def check(cls, **kwargs):
+        errors = super(BaseProduct, cls).check(**kwargs)
         try:
             cls.product_name
         except AttributeError:
             msg = "Class `{}` must provide a model field implementing `product_name`"
-            raise NotImplementedError(msg.format(cls.__name__))
+            errors.append(checks.Error(msg.format(cls.__name__)))
+        return errors
 
 ProductModel = deferred.MaterializedModel(BaseProduct)