覆盖保存方法在 Django Rest Framework 中不起作用

Question

我有一个模型（积分），它根据用户的购买来保存积分。我的做法是，在下订单时（调用 orderapi），通过订单实例传递一个信号，并根据金额计算点数，并使用 save 方法保存。

创建了 Alothugh Order 对象，我没有看到保存在数据库中的点。我不确定是什么问题。

我的模型：

class Order(models.Model):
    ORDER_STATUS = (
        ('To_Ship', 'To Ship',),
        ('Shipped', 'Shipped',),
        ('Delivered', 'Delivered',),
        ('Cancelled', 'Cancelled',),
    )
    user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True)   
    order_status = models.CharField(max_length=50,choices=ORDER_STATUS,default='To_Ship')
    ordered_date = models.DateTimeField(auto_now_add=True)
    ordered = models.BooleanField(default=False)   

    @property
    def total_price(self):
        # abc = sum([_.price for _ in self.order_items.all()])
        # print(abc)
        return sum([_.price for _ in self.order_items.all()])

    def __str__(self):
        return self.user.email

    class Meta:
        verbose_name_plural = "Orders"
        ordering = ('-id',)

class OrderItem(models.Model):       
    orderItem_ID = models.CharField(max_length=12, editable=False, default=id_generator)
    order = models.ForeignKey(Order,on_delete=models.CASCADE, blank=True,null=True,related_name='order_items')
    item = models.ForeignKey(Product, on_delete=models.CASCADE,blank=True, null=True)
    order_variants = models.ForeignKey(Variants, on_delete=models.CASCADE,blank=True,null=True)
    quantity = models.IntegerField(default=1)    

    @property
    def price(self):
        total_item_price = self.quantity * self.order_variants.price
        # print(total_item_price)
        return total_item_price    

    

class Points(models.Model):
    order = models.OneToOneField(Order,on_delete=models.CASCADE,blank=True,null=True)
    points_gained = models.IntegerField(default=0)

    def collect_points(sender,instance,created,**kwargs):
        total_price = instance.total_price
        if created:
            if total_price <= 10000:
                abc = 0.01 * total_price
            else:
                abc = 0.75 * total_price
            return abc

    post_save.connect(collect_points,sender=Order)

    def save(self,*args,**kwargs):
        self.points_gained = self.collect_points()
        super(Points, self).save(*args, **kwargs)

我实际上在这里感到困惑。我们可以使用 instance.total_price 访问属性 total_price 吗？

我的序列化器：

class OrderSerializer(serializers.ModelSerializer):
    billing_details = BillingDetailsSerializer()
    order_items = OrderItemSerializer(many=True)
    user = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault())
    #total_price = serializers.SerializerMethodField(source='get_total_price')
    class Meta:
        model = Order
        fields = ['id','user','ordered_date','order_status', 'ordered', 'order_items','total_price', 'billing_details']
        # depth = 1   

    def create(self, validated_data):
        user = self.context['request'].user
        if not user.is_seller:
            order_items = validated_data.pop('order_items')
            billing_details = validated_data.pop('billing_details')
            order = Order.objects.create(user=user,**validated_data)
            BillingDetails.objects.create(user=user,order=order,**billing_details)
            for order_items in order_items:
                OrderItem.objects.create(order=order,**order_items)
            order.save()
            return order
        else:
            raise serializers.ValidationError("This is not a customer account.Please login as customer.")

我的更新代码：

class Order(models.Model):
total_price = models.FloatField(blank=True,null=True)

    def final_price(self):      
        return  sum([_.price for _ in self.order_items.all()])

    def save(self, *args, **kwargs):
        self.total_price = self.final_price()
        super(Order, self).save(*args, **kwargs)

class Points(models.Model):
    order = models.OneToOneField(Order,on_delete=models.CASCADE,blank=True,null=True)
    points_gained = models.FloatField(default=0)

    def collect_points(sender,instance,created,**kwargs):
        total_price = instance.total_price
        print(total_price)
        if created:
            if total_price <= 10000:
                abc = 0.01 * total_price
            else:
                abc = 0.75 * total_price
        new_point = Points.objects.create(order=instance, points_gained=abc)

    post_save.connect(collect_points,sender=Order)

专注于这部分

Class Order(models.Model):
    total_price = models.FloatField(blank=True,null=True)

    def final_price(self):
        # abc = sum([_.price for _ in self.order_items.all()])
        # print(abc)
        return  sum([_.price for _ in self.order_items.all()])

    def save(self, *args, **kwargs):
        self.total_price = self.final_price()
        super(Order, self).save(*args, **kwargs)

Answer 1

虽然您确实将它放在您的 Point 模型中，但它不会影响它。它链接到Order 模型。如果我将您的信号翻译成英文，它将是：保存Order 实例后，计算并返回abc 变量。

我们绝不会在此处保存Point 模型或与之交互。因此，即使您确实覆盖了 Point.save() 方法，您也不会根据您的信号调用它

如果你想做的是创建Point实例：

def collect_points(sender, instance, created, **kwargs):
    total_price = instance.total_price
    if created:
        if total_price <= 10000:
            abc = 0.01 * total_price
        else:
            abc = 0.75 * total_price
        # ---> Now we can create the point
        new_point = Points.objects.create(order=instance, points_gained=abc)

post_save.connect(collect_points,sender=Order)

# And no need to override the save() method

所以现在，我们的信号意味着在保存Order 实例后，如果它已创建，则计算点并根据此数据创建Point 实例

此外，还有一些额外的提示可以让您在处理信号时更轻松：

• 创建一个signals.py 文件。长期管理最好将您的信号分组到特定文件中
• 把你的信号代码放在那里
• 你可以在你的函数上使用装饰器来使它们成为信号，比如@receiver(post_save, sender=Order)
• 在您的apps.py 文件中，在您的应用程序类中，覆盖ready 方法以导入信号。 ready 方法在启动应用程序时自动触发。所以这就像“在启动时执行此操作”。在我们的例子中，我们将在启动时注册信号。片段示例：

#apps.py

from django.apps import AppConfig

class SecurityConfig(AppConfig):

    name = "security"
    label = "security"

    def ready(self):
        """Imports signals on application start"""

        import security.signals

---

编辑：使用类方法和独立信号

# In models.py
class Points(models.Model):
    order = models.OneToOneField(Order,on_delete=models.CASCADE,blank=True,null=True)
    points_gained = models.IntegerField(default=0)
    
    @classmethod
    def create_point_from_order(cls, order_instance):
        """Creates a Points instance from an order"""
        total_price = order_instance.total_price
        if total_price <= 10000:
            abc = 0.01 * total_price
        else:
            abc = 0.75 * total_price
        return cls.objects.create(order=order_instance, points_gained=abc)

然后您可以在调用该方法的Order 模型上创建一个信号

# In signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Order, Points


@receiver(post_save, sender=Order)
def create_point_for_order(sender, instance, created, **kwargs):
    """On Order creation, creates a matching Points instance"""
    if created:
        created_point = Points.create_point_from_order(instance)

最后，我们通过确保在启动时调用 signals.py 文件来注册该信号

# In apps.py

from django.apps import AppConfig

class YourAppNameConfig(AppConfig):

    name = "your.app.name"
    label = "your.app.name"

    def ready(self):
        import yourappname.signals

这样：

• 逻辑仍在模型中，在create_point_from_order方法中
• 这使我们可以从信号中分离逻辑，并使其可重用
• 然后我们只需注册一个Order 信号，其工作就是简单地调用该点创建方法

Answer 2

这是一个明显的例子，信号不适合。两种模型都在您的控制之下，您已经覆盖了 Order save 方法。这项工作零需要使用信号，它只会使事情复杂化。

这是简单的方法：

class Order(models.Model):
    total_price = models.FloatField(blank=True,null=True)

    def final_price(self):      
        return  sum([_.price for _ in self.order_items.all()])

    def save(self, force_insert=False, **kwargs):
        created = force_insert or not self.pk
        self.total_price = self.final_price()
        super(Order, self).save(force_insert=force_insert, **kwargs)
        if created:
            points = Points.calculate_points(self.total_price)
            Points.objects.create(order=self, points_gained=points)

class Points(models.Model):
    order = models.OneToOneField(
        Order,on_delete=models.CASCADE,blank=True,null=True
    )
    points_gained = models.FloatField(default=0)

    @staticmethod
    def calculate_points(amount):
        return 0.01 * amount if amount <= 10000 else 0.75 * amount

信号是如何工作的？

信号是库将任意代码注入到它们控制的一段代码中的方式：

# Somebody else's code, you cannot modify
def greeting():
    print('Hello ')
    send_signal('after_print_hello')
    print('!')

现在这段代码有一些方法可以注册 'after_print_hello' 信号，这被称为接收器：

# Your code
def on_after_print_hello():
    print('world')

所以最终会发生这种情况：

def greeting():
    print('Hello ')
    print('world') <-----------\
    print('!')                 |
                               |
def on_after_print_hello():    |
    print('world')  -----------/

如果代码的两部分都是你的，那么在这里使用信号似乎是绝对无稽之谈。您可以将打印语句移动到您想要的位置。

如果你去掉所有花哨的注册和接收器匹配，这正是 Django 信号正在发生的事情。这些post_save 信号仅在您想在模型保存后 为您的模型中添加额外步骤时才有用。如果您将它们用于您自己的模型，您只需将 print('world') 语句移动到不同的位置，并使用 Django 使用更复杂的 API 为您调用它。