如何解决覆盖保存方法在 Django Rest Framework 中不起作用
我有一个模型（积分），它根据用户的购买来保存积分。我以这样的方式制作订单（调用orderapi），通过订单实例传递一个信号，并根据数量计算点数，并使用save方法保存它。
虽然创建了 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,blank=True,null=True,related_name='order_items')
item = models.ForeignKey(Product,null=True)
order_variants = models.ForeignKey(Variants,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,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,**kwargs):
self.total_price = self.final_price()
super(Order,**kwargs)
class Points(models.Model):
order = models.OneToOneField(Order,null=True)
points_gained = models.FloatField(default=0)
def collect_points(sender,**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,**kwargs)
解决方法
虽然您确实将其放入 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,**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信号，其工作就是简单地调用该点创建方法
这是一个明显的例子，其中信号不合适。这两种模型都在您的控制之下，您已经覆盖了 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,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 为您调用它。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
