class OrderSerializer(serializers.ModelSerializer):
"""
订单序列化
"""
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
order_sn = serializers.CharField(read_only=True)
trade_no = serializers.CharField(read_only=True)
pay_status = serializers.CharField(read_only=True)
pay_time = serializers.DateTimeField(read_only=True)
order_mount = serializers.FloatField(read_only=True)
add_time = serializers.DateTimeField(read_only=True)
alipay_url = serializers.SerializerMethodField(read_only=True)
def generate_order_sn(self):
"""
生成订单号 当前时间 + userid + 随机数
"""
order_sn = "{time_str}{user_id}{ran_str}".format(
time_str=time.strftime("%Y%m%d%H%M%S"),
user_id=self.context["request"].user.id,
ran_str="".join(random.choice(string.digits) for x in range(2)))
return order_sn
def validate(self, attrs):
shopping_carts = ShoppingCart.objects.filter(
user=self.context['request'].user)
total_price = 0
for shopping_cart in shopping_carts:
total_price += shopping_cart.goods.goods.price * shopping_cart.nums
attrs["order_mount"] = total_price
attrs["order_sn"] = self.generate_order_sn()
return attrs
def validate_signer_mobile(self, signer_mobile):
if not re.match(REGEX_MOBILE, signer_mobile):
raise serializers.ValidationError("手机号码不合法")
return signer_mobile
def get_alipay_url(self, obj):
"""
生成支付宝连接
"""
alipay = AliPay(
appid="2016080900200120",
app_notify_url="http://111.230.186.193:8000/alipay/return/",
app_private_key_path=private_key_path,
alipay_public_key_path=
ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
debug=True, # 默认False,
return_url="http://111.230.186.193:8000/alipay/return/")
url = alipay.direct_pay(
subject=obj.order_sn,
out_trade_no=obj.order_sn,
total_amount=obj.order_mount,
)
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(
data=url)
return re_url
class Meta:
model = OrderInfo
fields = ("id", "user", "order_sn", "trade_no", "pay_status",
"order_mount", "pay_time", "address", "signer_name",
"signer_mobile", "add_time", "alipay_url")
class FavoritesSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Favorites
fields = ('recipe', 'user')
class OrderCreateSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Order
fields = '__all__'
class ArchiveSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Archive
fields = '__all__'
class ExpensesSerializer(AdminExpensesSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class NestedBookSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
book = serializers.HiddenField(default=CurrentBookDefault())
class Meta:
fields = '__all__'
class OrderInfoSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
# 订单号
order_sn = serializers.CharField(read_only=True)
# 交易号
trade_no = serializers.CharField(read_only=True)
# 支付状态
pay_status = serializers.CharField(read_only=True)
# 支付时间
pay_time = serializers.DateTimeField(read_only=True,
format='%Y-%m-%d %H-%M')
# 生成订单时间
add_time = serializers.DateTimeField(read_only=True,
format='%Y-%m-%d %H-%M')
# 生成支付的url地址
alipay_url = serializers.SerializerMethodField(read_only=True)
def get_alipay_url(self, row):
# row -> OrderInfo
ailpay = AliPay(
appid='2016101100659996',
# 当用户没有在支付页面立即支付,而在其他地方支付完成
# 这是会走app_notify这个回调接口
app_notify_url='http://127.0.0.1:8000/api/ailpay/return/',
# 设置app的路径
app_private_key_path=APP_PRIVATE_KEY_PATH,
# 支付宝公钥
alipay_public_key_path=ALIPAY_PUBLIC_KEY_PATH,
debug=True,
return_url='http://127.0.0.1:8000/api/ailpay/return/')
# 生成支付宝的url地址
url_data = ailpay.direct_pay(
# 标题
subject=row.order_sn,
# 交易号
out_trade_no=row.order_sn,
# 订单价格
total_amount=row.order_mount)
pay_url = 'https://openapi.alipaydev.com/gateway.do?{data}'.format(
data=url_data)
# print(pay_url)
return pay_url
# 生成订单号
def create_order_sn(self):
# 当前时间 用户id 随机数字
random_ins = random.Random()
order_sn = '{timesstr}{userid}{randomstr}'.format(
timesstr=time.strftime('%Y%m%d%H%M%S'),
userid=self.context['request'].user.id,
randomstr=random_ins.randint(1, 99))
return order_sn
def validate(self, attrs):
# 字段完成后会经过这个方法
attrs['order_sn'] = self.create_order_sn()
return attrs
class Meta:
model = OrderInfo
fields = '__all__'
class UserFavSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = UserFav
fields = ('user', 'goods', 'id')
class SolutionSerializer(serializers.ModelSerializer):
student = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Solution
fields = '__all__'
class SubCategoriaSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = SubCategoria
fields = '__all__'
class ProductoSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Producto
fields = '__all__'
class OrderSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(
default=serializers.CurrentUserDefault()
)
# 生成订单的时候这些不用post
# 订单状态
pay_status = serializers.CharField(read_only=True)
# 订单号一定要唯一(unique=True)
order_sn = serializers.CharField(read_only=True)
# 支付时间
pay_time = serializers.DateTimeField(read_only=True)
# 订单的支付类型
pay_type = serializers.CharField(read_only=True)
# 支付宝交易号
trade_no = serializers.CharField(read_only=True)
# 微信支付会用到
nonce_str = serializers.CharField(read_only=True)
# 订单添加时间是只读的
add_time = serializers.DateTimeField(read_only=True)
# 订单的金额是只读的
order_mount = serializers.FloatField(read_only=True)
# 支付订单的url
alipay_url = serializers.SerializerMethodField(read_only=True)
def get_alipay_url(self, obj):
# 实例化AliPay的对象
alipay = AliPay(
appid=APPID,
# 支付成功之后通知的url地址，以post方法提交
app_notify_url="http://118.190.210.92:8000/alipay/return/",
# 应用私钥
app_private_key_path=private_key_path,
# 支付宝的公钥
alipay_public_key_path=ali_pub_key_path,
debug=True, # 默认False,
# 支付成功之后通返回的url地址，以get方法提交
return_url="http://118.190.210.92:8000/alipay/return/"
)
data = alipay.direct_pay(
subject=obj.order_sn, # 支付的标题时订单号
out_trade_no=obj.order_sn,
total_amount=obj.order_mount,
)
re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=data)
return re_url
def generate_order_sn(self):
# 生成订单号
# 当前时间 + userid + 随机数
from random import Random
random_ins = Random()
order_sn = "{time_str}{userid}{ranstr}".format(
time_str=time.strftime("%Y%m%d%H%M%S"),
userid=self.context["request"].user.id,
ranstr=random_ins.randint(10, 99))
return order_sn
def validate(self, attrs):
# validate中添加order_sn,然后在view中就可以save
attrs["order_sn"] = self.generate_order_sn()
return attrs
class Meta:
model = OrderInfo
fields = "__all__"
class UserSerializer(vst_serializers.UserSerializer):
is_staff = serializers.HiddenField(default=True, label='Staff')
@with_signals
def update(self, instance: User, validated_data: Dict):
return super(UserSerializer, self).update(instance, validated_data)
class StatusUpdateSerializer(ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = StatusUpdate
class EventDetailSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = EventModel
fields = ('owner', 'date', 'workType', 'workTime', 'name')
class UserSketchSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Sketch
fields = "__all__"
class UploadBookSerializer(serializers.ModelSerializer):
file = serializers.FileField(allow_empty_file=False,
use_url=False,
required=False)
uploader = serializers.HiddenField(
default=serializers.CurrentUserDefault())
pdf = serializers.FileField(use_url=False, required=False)
class Meta:
model = Book
fields = '__all__'
read_only_fields = [
'content', 'data', 'uploader', 'has_audio', 'approved',
'read_count', 'download_count', 'page_count', 'search_count',
'type'
]
extra_kwargs = {
'title': {
'required': True
},
'content': {
'required': False,
'allow_null': True
},
'data': {
'required': False,
'allow_null': True
},
'author': {
'required': True
},
'file': {
'required': False,
'allow_null': True,
'read_only': False
},
'pdf': {
'required': False,
'allow_null': True
},
'category': {
'required': True
},
}
def __init__(self, **kwargs):
self.json_data = None
super().__init__(**kwargs)
def validate_file(self, file):
if not file:
return file
try:
self.json_data = json.load(file)
except:
raise serializers.ValidationError(_('Bad json file'))
return file
def validate_pdf(self, pdf):
if not pdf:
return pdf
filename, file_extension = os.path.splitext(pdf.name)
if not file_extension or file_extension.lower() != '.pdf':
raise serializers.ValidationError(_('Bad PDF file'))
return pdf
def get_data(self):
return munchify(self.json_data) if self.json_data else None
def create(self, validated_data):
data = validated_data
if self.json_data:
data['content'] = self.json_data['pages']
data['data'] = self.json_data
data['page_count'] = len(self.json_data['pages'])
if 'description' not in data.keys(
) and self.json_data['meta']['betaka']:
data['description'] = self.json_data['meta']['betaka']
if data.__contains__('file'):
data.pop('file')
pdf = None
if data.__contains__('pdf'):
pdf = data.pop('pdf')
book = Book.objects.create(**data)
if pdf:
BookPDF.objects.update_or_create(book_id=book.id,
user=book.uploader,
url=pdf)
return book
class UserFavSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = UserFav
fields = ("user", "goods", "id")
class CreateRideSerializer(serializers.ModelSerializer):
"""Create ride serializer."""
offered_by = serializers.HiddenField(
default=serializers.CurrentUserDefault())
available_seats = serializers.IntegerField(min_value=1, max_value=15)
class Meta:
"""Meta class."""
model = Ride
exclude = ('offered_in', 'passengers', 'rating', 'is_active')
def validate_departure_date(self, data):
"""Verify date is not in the past."""
min_date = timezone.now() + timedelta(minutes=10)
if data < min_date:
raise serializers.ValidationError(
'Departure time must be at least pass the next 20 minutes window.'
)
return data
def validate(self, data):
"""Validate.
Verify that the person who offers the ride is member and also
the same user making the request.
"""
user = data['offered_by']
circle = self.context['circle']
if self.context['request'].user != user:
raise serializers.ValidationError(
'Ride offerd on behalf of others are not allowed.')
try:
membership = Membership.objects.get(user=user,
circle=circle,
is_active=True)
except membership.DoesNotExist:
raise serializers.ValidationError(
'User is not an ative member of the circle.')
if data['arrival_date'] <= data['departure_date']:
raise serializers.ValidationError(
'Departure date must happen after arrival date.')
self.context['membership'] = membership
return data
def create(self, data):
"""Create ride and update stats."""
circle = self.context['circle']
ride = Ride.objects.create(**data, offered_in=circle)
# Circle
circle.rides_offered += 1
circle.save()
# Membership
membership = self.context['membership']
membership.rides_offered += 1
membership.save()
# Profile
profile = data['offered_by'].profile
profile.rides_offered += 1
profile.save()
return ride
class SubRoutineSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = SubRoutine
fields = ('id', 'user', 'content_json', 'yield_method')
class FavoriteSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Favorite
fields = '__all__'
class OrderCreateSerializer(serializers.ModelSerializer):
product = serializers.PrimaryKeyRelatedField(
required=True, queryset=Product.objects.all())
size = serializers.PrimaryKeyRelatedField(
default=None, queryset=ProductSize.objects.all())
order_line = serializers.HiddenField(default=CurrentOrderLineDefault())
quantity = serializers.IntegerField(min_value=1, max_value=100, default=1)
def validate_product(self, product: Product):
if not product.active:
raise serializers.ValidationError(
"Produktet er ikke lenger aktivt og kan ikke kjøpes")
if timezone.now() > product.deadline:
raise serializers.ValidationError(
"Tidsfristen for å kjøpe produktet har utgått")
if product.stock == 0:
raise serializers.ValidationError(
"Det er ikke flere varer igjen av produktet")
return product
def validate_size(self, size: ProductSize):
product_id: int = self.initial_data.get("product")
quantity: int = self.initial_data.get("quantity", 1)
if product_id:
product = Product.objects.get(pk=product_id)
allowed_sizes = product.product_sizes.all()
has_size = allowed_sizes.count() > 0
if not has_size and size:
raise serializers.ValidationError(
"Du kan ikke velge en størrelse for dette produktet")
if has_size and not size:
raise serializers.ValidationError(
"Dette produktet krever at du velger en størrelse")
if has_size and size not in allowed_sizes:
raise serializers.ValidationError(
"Den gitte størrelsen er ikke tilgjengelig for dette produktet"
)
if not product.enough_stock(quantity, size):
if not size:
raise serializers.ValidationError(
"Det er ikke flere varer igjen av dette produktet")
else:
raise serializers.ValidationError(
"Det er ikke flere varer igjen av dette produktet in denne størrelsen"
)
return size
def validate_order_line(self, order_line: OrderLine):
request = self.context.get("request")
if order_line.user != request.user:
raise serializers.ValidationError(
"Du kan ikke legge varer til andre brukeres handlevogn")
return order_line
def validate(self, data):
order_line: OrderLine = data.get("order_line")
product: Product = data.get("product")
products_in_order_line = [
order.product for order in order_line.orders.all()
]
if product in products_in_order_line:
raise serializers.ValidationError(
"Dette produktet er allerede i handlevognen din")
return super().validate(data)
def create(self, validated_data):
product: Product = validated_data.get("product")
order = super().create({
**validated_data,
"price": product.
price, # Add the current price of the product as the price of the order
})
if not order.is_valid():
order.delete()
raise serializers.ValidationError("Ordren er ikke gyldig")
return order
class Meta:
model = Order
fields = (
"id",
"product",
"price",
"quantity",
"size",
"is_valid",
"order_line",
)
class CategorySerializer(AdminCategorySerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class DeviceSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Device
fields = ('user', 'device_id')
class IncomeSerializer(AdminIncomeSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class CarDetailSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Car
fields = '__all__'
class TestSerializer(serializers.Serializer):
published = serializers.HiddenField(default=True)
class ScoreWriteSerializer(serializers.ModelSerializer):
owner = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Score
fields = ['count', 'owner']
class CatalogCreateSerializer(serializers.ModelSerializer):
baker = serializers.HiddenField(default=serializers.CurrentUserDefault())
class Meta:
model = Catalog
fields = '__all__'
class UserReferenceSerializerMixin(serializers.ModelSerializer):
# this automatically includes the current user in the serializer so the request doesn't have to send it along
user = serializers.HiddenField(
default=serializers.CurrentUserDefault()
)
