Merge pull request #3922 from viggo-devries/consume_atomic_state

Atomically consume allocations and stock

src/oscar/apps/partner/abstract_models.py

 from django.db import models, router
-from django.db.models import F, Value, signals
-from django.db.models.functions import Coalesce
+from django.db.models import F, signals
+from django.db.models.functions import Coalesce, Least
 from django.utils.functional import cached_property
 from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
         # Doesn't make sense to allocate if stock tracking is off.
         if not self.can_track_allocations:
             return
+
         # Send the pre-save signal
-        signals.pre_save.send(
-            sender=self.__class__,
-            instance=self,
-            created=False,
-            raw=False,
-            using=router.db_for_write(self.__class__, instance=self))
+        self.pre_save_signal()
 
         # Atomic update
-        (self.__class__.objects
-            .filter(pk=self.pk)
-            .update(num_allocated=(
-                Coalesce(F('num_allocated'), Value(0)) + quantity)))
+        (
+            self.__class__.objects.filter(pk=self.pk).update(
+                num_allocated=(Coalesce(F("num_allocated"), 0) + quantity)
+            )
+        )
 
         # Make sure the current object is up-to-date
-        if self.num_allocated is None:
-            self.num_allocated = 0
-        self.num_allocated += quantity
+        self.refresh_from_db(fields=["num_allocated"])
 
         # Send the post-save signal
-        signals.post_save.send(
-            sender=self.__class__,
-            instance=self,
-            created=False,
-            raw=False,
-            using=router.db_for_write(self.__class__, instance=self))
+        self.post_save_signal()
 
     allocate.alters_data = True
 
         if not self.is_allocation_consumption_possible(quantity):
             raise InvalidStockAdjustment(
                 _('Invalid stock consumption request'))
-        self.num_allocated -= quantity
-        self.num_in_stock -= quantity
-        self.save()
+
+        # send the pre save signal
+        self.pre_save_signal()
+
+        # Atomically consume allocations and stock
+        (
+            self.__class__.objects.filter(pk=self.pk).update(
+                num_allocated=(Coalesce(F("num_allocated"), 0) - quantity),
+                num_in_stock=(Coalesce(F("num_in_stock"), 0) - quantity),
+            )
+        )
+
+        # Make sure current object is up-to-date
+        self.refresh_from_db(fields=["num_allocated", "num_in_stock"])
+
+        # Send the post-save signal
+        self.post_save_signal()
+
     consume_allocation.alters_data = True
 
     def cancel_allocation(self, quantity):
         if not self.can_track_allocations:
             return
-        # We ignore requests that request a cancellation of more than the
-        # amount already allocated.
-        self.num_allocated -= min(self.num_allocated, quantity)
-        self.save()
+
+        # send the pre save signal
+        self.pre_save_signal()
+
+        # Atomically consume allocations
+        (
+            self.__class__.objects.filter(pk=self.pk).update(
+                num_allocated=Coalesce(F("num_allocated"), 0)
+                - Least(Coalesce(F("num_allocated"), 0), quantity),
+            )
+        )
+
+        # Make sure current object is up-to-date
+        self.refresh_from_db(fields=["num_allocated"])
+
+        # Send the post-save signal
+        self.post_save_signal()
+
     cancel_allocation.alters_data = True
 
+    def pre_save_signal(self):
+        signals.pre_save.send(
+            sender=self.__class__,
+            instance=self,
+            created=False,
+            raw=False,
+            using=router.db_for_write(self.__class__, instance=self))
+
+    def post_save_signal(self):
+        signals.post_save.send(
+            sender=self.__class__,
+            instance=self,
+            created=False,
+            raw=False,
+            using=router.db_for_write(self.__class__, instance=self))
+
     @property
     def is_below_threshold(self):
         if self.low_stock_threshold is None: