重写保存方法在Django Rest Framework中不起作用

Question

我有一个模型(积分(，它根据用户的购买情况保存积分。我以这样一种方式制作了订单(调用orderapi(时，会通过订单实例传递一个信号，并根据数量计算点数，然后使用save方法保存。

创建了一个高阶对象，我看不到这些点被保存在数据库中。我不确定问题出在哪里。

我的型号：

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

这是一个明显的例子，其中信号不太适合。这两个模型都已经在您的控制之下，您已经覆盖了Order保存方法。这项工作不需要使用信号，而且只会使事情变得复杂。

这是一个简单的方法：

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为您调用它。

Answer 2

虽然您确实将它放在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文件。对于长期管理来说，最好将您的信号分组到一个特定的文件中
• 把你的信号码放在那里
• 您可以在函数上使用decorator使其成为信号，如@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

---

EDIT：使用类方法和独立信号

# 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信号，其工作就是简单地调用该点创建方法