from goods.base_views import Goodslistviewurl(r'^goods/$',Goodslistview.as_view(),name='goods_list'),

from datetime import datetimefrom django.db import models
from DjangoUeditor.models import UEditorFieldclass Goods(models.Model):"""商品"""category = models.ForeignKey(GoodsCategory, verbose_name="商品类目")goods_sn = models.CharField(max_length=50, default="", verbose_name="商品唯一货号")name = models.CharField(max_length=100, verbose_name="商品名")click_num = models.IntegerField(default=0, verbose_name="点击数")sold_num = models.IntegerField(default=0, verbose_name="商品销售量")fav_num = models.IntegerField(default=0, verbose_name="收藏数")goods_num = models.IntegerField(default=0, verbose_name="库存数")market_price = models.FloatField(default=0, verbose_name="市场价格")shop_price = models.FloatField(default=0, verbose_name="本店价格")goods_brief = models.TextField(max_length=500, verbose_name="商品简短描述")goods_desc = UEditorField(verbose_name=u"内容", imagePath="goods/images/", width=1000, height=300,filePath="goods/files/", default='')ship_free = models.BooleanField(default=True, verbose_name="是否承担运费")goods_front_image = models.ImageField(upload_to="goods/images/", null=True, blank=True, verbose_name="封面图")is_new = models.BooleanField(default=False, verbose_name="是否新品")is_hot = models.BooleanField(default=False, verbose_name="是否热销")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = '商品'verbose_name_plural = verbose_namedef __str__(self):return self.name

from datetime import datetimefrom django.db import models
from DjangoUeditor.models import UEditorField
# Create your models here.class GoodsCategory(models.Model):"""商品类别"""CATEGORY_TYPE = ((1, "一级类目"),(2, "二级类目"),(3, "三级类目"),)name = models.CharField(default="", max_length=30, verbose_name="类别名", help_text="类别名")code = models.CharField(default="", max_length=30, verbose_name="类别code", help_text="类别code")desc = models.TextField(default="", verbose_name="类别描述", help_text="类别描述")category_type = models.IntegerField(choices=CATEGORY_TYPE, verbose_name="类目级别", help_text="类目级别")parent_category = models.ForeignKey("self", null=True, blank=True, verbose_name="父类目级别", help_text="父目录",related_name="sub_cat")is_tab = models.BooleanField(default=False, verbose_name="是否导航", help_text="是否导航")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "商品类别"verbose_name_plural = verbose_namedef __str__(self):return self.nameclass GoodsCategoryBrand(models.Model):"""品牌名"""category = models.ForeignKey(GoodsCategory, related_name='brands', null=True, blank=True, verbose_name="商品类目")name = models.CharField(default="", max_length=30, verbose_name="品牌名", help_text="品牌名")desc = models.TextField(default="", max_length=200, verbose_name="品牌描述", help_text="品牌描述")image = models.ImageField(max_length=200, upload_to="brands/")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "品牌"verbose_name_plural = verbose_namedb_table = "goods_goodsbrand"def __str__(self):return self.nameclass Goods(models.Model):"""商品"""category = models.ForeignKey(GoodsCategory, verbose_name="商品类目")goods_sn = models.CharField(max_length=50, default="", verbose_name="商品唯一货号")name = models.CharField(max_length=100, verbose_name="商品名")click_num = models.IntegerField(default=0, verbose_name="点击数")sold_num = models.IntegerField(default=0, verbose_name="商品销售量")fav_num = models.IntegerField(default=0, verbose_name="收藏数")goods_num = models.IntegerField(default=0, verbose_name="库存数")market_price = models.FloatField(default=0, verbose_name="市场价格")shop_price = models.FloatField(default=0, verbose_name="本店价格")goods_brief = models.TextField(max_length=500, verbose_name="商品简短描述")goods_desc = UEditorField(verbose_name=u"内容", imagePath="goods/images/", width=1000, height=300,filePath="goods/files/", default='')ship_free = models.BooleanField(default=True, verbose_name="是否承担运费")goods_front_image = models.ImageField(upload_to="goods/images/", null=True, blank=True, verbose_name="封面图")is_new = models.BooleanField(default=False, verbose_name="是否新品")is_hot = models.BooleanField(default=False, verbose_name="是否热销")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = '商品'verbose_name_plural = verbose_namedef __str__(self):return self.nameclass IndexAd(models.Model):category = models.ForeignKey(GoodsCategory, related_name='category', verbose_name="商品类目")goods = models.ForeignKey(Goods, related_name='goods')class Meta:verbose_name = '首页商品类别广告'verbose_name_plural = verbose_namedef __str__(self):return self.goods.nameclass GoodsImage(models.Model):"""商品轮播图"""goods = models.ForeignKey(Goods, verbose_name="商品", related_name="images")image = models.ImageField(upload_to="", verbose_name="图片", null=True, blank=True)add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = '商品图片'verbose_name_plural = verbose_namedef __str__(self):return self.goods.nameclass Banner(models.Model):"""轮播的商品"""goods = models.ForeignKey(Goods, verbose_name="商品")image = models.ImageField(upload_to='banner', verbose_name="轮播图片")index = models.IntegerField(default=0, verbose_name="轮播顺序")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = '轮播商品'verbose_name_plural = verbose_namedef __str__(self):return self.goods.nameclass HotSearchWords(models.Model):"""热搜词"""keywords = models.CharField(default="", max_length=20, verbose_name="热搜词")index = models.IntegerField(default=0, verbose_name="排序")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = '热搜词'verbose_name_plural = verbose_namedef __str__(self):return self.keywords

from datetime import datetimefrom django.db import models
from users.models import UserProfilefrom goods.models import Goods
# User = get_user_model()
# Create your models here.class ShoppingCart(models.Model):"""购物车"""user = models.ForeignKey(UserProfile, verbose_name=u"用户")goods = models.ForeignKey(Goods, verbose_name=u"商品")nums = models.IntegerField(default=0, verbose_name="购买数量")add_time = models.DateTimeField(default=datetime.now, verbose_name=u"添加时间")class Meta:verbose_name = '购物车'verbose_name_plural = verbose_nameunique_together = ("user", "goods")def __str__(self):return "%s(%d)".format(self.goods.name, self.nums)class OrderInfo(models.Model):"""订单"""ORDER_STATUS = (("TRADE_SUCCESS", "成功"),("TRADE_CLOSED", "超时关闭"),("WAIT_BUYER_PAY", "交易创建"),("TRADE_FINISHED", "交易结束"),("paying", "待支付"),)user = models.ForeignKey(UserProfile, verbose_name="用户")order_sn = models.CharField(max_length=30, null=True, blank=True, unique=True, verbose_name="订单号")trade_no = models.CharField(max_length=100, unique=True, null=True, blank=True, verbose_name=u"交易号")pay_status = models.CharField(choices=ORDER_STATUS, default="paying", max_length=30, verbose_name="订单状态")post_script = models.CharField(max_length=200, verbose_name="订单留言")order_mount = models.FloatField(default=0.0, verbose_name="订单金额")pay_time = models.DateTimeField(null=True, blank=True, verbose_name="支付时间")# 用户信息address = models.CharField(max_length=100, default="", verbose_name="收货地址")signer_name = models.CharField(max_length=20, default="", verbose_name="签收人")singer_mobile = models.CharField(max_length=11, verbose_name="联系电话")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = u"订单"verbose_name_plural = verbose_namedef __str__(self):return str(self.order_sn)class OrderGoods(models.Model):"""订单的商品详情"""order = models.ForeignKey(OrderInfo, verbose_name="订单信息", related_name="goods")goods = models.ForeignKey(Goods, verbose_name="商品")goods_num = models.IntegerField(default=0, verbose_name="商品数量")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "订单商品"verbose_name_plural = verbose_namedef __str__(self):return str(self.order.order_sn)

from datetime import datetimefrom django.db import models
from users.models import UserProfile
# from django.contrib.auth import get_user_model  # settings中设置了AUTH_USER_MODEL
# User = get_user_model()from goods.models import Goodsclass UserFav(models.Model):"""用户收藏"""user = models.ForeignKey(UserProfile, verbose_name="用户")goods = models.ForeignKey(Goods, verbose_name="商品", help_text="商品id")add_time = models.DateTimeField(default=datetime.now, verbose_name=u"添加时间")class Meta:verbose_name = '用户收藏'verbose_name_plural = verbose_nameunique_together = ("user", "goods")def __str__(self):return self.user.usernameclass UserLeavingMessage(models.Model):"""用户留言"""MESSAGE_CHOICES = ((1, "留言"),(2, "投诉"),(3, "询问"),(4, "售后"),(5, "求购"))user = models.ForeignKey(UserProfile, verbose_name="用户")message_type = models.IntegerField(default=1, choices=MESSAGE_CHOICES, verbose_name="留言类型",help_text=u"留言类型: 1(留言),2(投诉),3(询问),4(售后),5(求购)")subject = models.CharField(max_length=100, default="", verbose_name="主题")message = models.TextField(default="", verbose_name="留言内容", help_text="留言内容")file = models.FileField(upload_to="message/images/", verbose_name="上传的文件", help_text="上传的文件")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "用户留言"verbose_name_plural =  verbose_namedef __str__(self):return self.subjectclass UserAddress(models.Model):"""用户收货地址"""user = models.ForeignKey(UserProfile, verbose_name="用户")province = models.CharField(max_length=100, default="", verbose_name="省份")city = models.CharField(max_length=100, default="", verbose_name="城市")district = models.CharField(max_length=100, default="", verbose_name="区域")address = models.CharField(max_length=100, default="", verbose_name="详细地址")signer_name = models.CharField(max_length=100, default="", verbose_name="签收人")signer_mobile = models.CharField(max_length=11, default="", verbose_name="电话")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "收货地址"verbose_name_plural = verbose_namedef __str__(self):return self.address

from datetime import datetimefrom django.db import models
from django.contrib.auth.models import AbstractUser
# Create your models here.class UserProfile(AbstractUser):"""用户"""name = models.CharField(max_length=30, null=True, blank=True, verbose_name="姓名")birthday = models.DateField(null=True, blank=True, verbose_name="出生年月")gender = models.CharField(max_length=6, choices=(("male", u"男"), ("female", "女")), default="female", verbose_name="性别")mobile = models.CharField(null=True, blank=True, max_length=11, verbose_name="电话")email = models.EmailField(max_length=100, null=True, blank=True, verbose_name="邮箱")class Meta:verbose_name = "用户"verbose_name_plural = verbose_namedef __str__(self):return self.usernameclass VerifyCode(models.Model):"""短信验证码"""code = models.CharField(max_length=10, verbose_name="验证码")mobile = models.CharField(max_length=11, verbose_name="电话")add_time = models.DateTimeField(default=datetime.now, verbose_name="添加时间")class Meta:verbose_name = "短信验证码"verbose_name_plural = verbose_namedef __str__(self):return self.code

from rest_framework.validators import UniqueValidatorclass UserRegSerializer(serializers.ModelSerializer):code = serializers.CharField(required=True,max_length=4,min_length=4,error_messages={"blank":"该字段不能为空","required":"请输入验证码", # required针对字段名称都没有，此处post空数据需要用blank提醒"max_length":"验证码格式错误","min_length":"验证码格式错误",},help_text="验证码",)username = serializers.CharField(required=True,allow_blank=False,validators=[UniqueValidator(queryset=User.objects.all(),message="用户已存在")],)def validate_code(self, code):"""验证码错误：1.验证码不存在，输入错误2.自带验证，最大长度最小长度为43.验证码过期4.两次验证码以最后面为准:param code::return:"""# try:  # 使用get会抛异常错误，需要提前断言#     verify_records = VerifyCode.objects.get(mobile=self.initial_data["username"], code=code)# except VerifyCode.DoesNotExist as e:#     pass# except VerifyCode.MultipleObjectsReturned as e:#     pass# 用户注册，已post方式提交注册信息，post的数据都保存在initial_data里面# username就是用户注册的手机号，验证码按添加时间倒序排序，为了后面验证过期，错误等verify_records = VerifyCode.objects.filter(mobile=self.initial_data["username"]).order_by("-add_time")if verify_records:last_records = verify_records[0] # 获取最后一条数据
five_mintes_ago = datetime.now() - timedelta(hours=0, minutes=1, seconds=0)if five_mintes_ago > last_records.add_time:raise serializers.ValidationError("验证码过期")if last_records != code:raise serializers.ValidationError("验证码错误")else:   # 记录不存在raise serializers.ValidationError("验证码错误")def validate(self, attrs):  # 所有字段,attrs是字段验证合法之后返回的总的dict# 前端没有传mobile值到后端，这里添加进来attrs["mobile"] = attrs["username"]# code是自己添加的，数据库中没有这个字段，验证完就删除掉del attrs["code"]return attrsclass Meta:model = User # UserProfile继承的是django自带的User,username为必填字段fields = ("username","code","mobile")

from users.serializers import UserRegSerializer
class UserViewset(CreateModelMixin, viewsets.GenericViewSet):"""用户"""serializer_class = UserRegSerializer

class UserViewset(CreateModelMixin, viewsets.GenericViewSet):"""用户"""serializer_class = UserRegSerializerqueryset = User.objects.all()

# 设置password不能明文显示和加密保存
password = serializers.CharField(style={'input_type': 'password'}, label="密码", write_only=True,
)

# 密码加密保存
def create(self, validated_data):user = super(UserRegSerializer, self).create(validated_data=validated_data)user.set_password(validated_data["password"])user.save()return user

from django.db.models.signals import post_save
from django.dispatch import receiverfrom django.contrib.auth import get_user_model
User = get_user_model()# post_save:接收信号的方式
#sender: 接收信号的model
@receiver(post_save, sender=User)
def create_user(sender, instance=None, created=False, **kwargs):# 是否新建，因为update的时候也会进行post_saveif created:password = instance.password#instance相当于user
        instance.set_password(password)instance.save()

from django.apps import AppConfigclass UsersConfig(AppConfig):name = 'users'verbose_name = '用户管理'def ready(self):import users.signals

class UserViewset(CreateModelMixin, viewsets.GenericViewSet):"""用户"""serializer_class = UserRegSerializerqueryset = User.objects.all()# 注册完成后实现登录，把token返回回来def create(self, request, *args, **kwargs):serializer = self.get_serializer(data=request.data)serializer.is_valid(raise_exception=True)user = self.perform_create(serializer)# 通过User生成jwt token#  数据放在data中，先序列化，在取出返回给用户re_dict = serializer.datapayload = jwt_payload_handler(user)re_dict["token"] = jwt_encode_handler(payload)re_dict["name"] = user.name if user.name else user.usernameheaders = self.get_success_headers(serializer.data)return Response(re_dict, status=status.HTTP_201_CREATED, headers=headers)def perform_create(self, serializer):# 返回的是UserRegSerializer中model的对象(也就是User)return serializer.save()

class GoodsImageSerializer(serializers.ModelSerializer):class Meta:model = GoodsImagefields = ("image",)class GoodsSerializer(serializers.ModelSerializer):# 覆盖外键字段category = CategorySerializer()    # category为外键字段，实例化操作images = GoodsImageSerializer(many=True) # 变量名为外键的related_nameclass Meta:model = Goods# fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')fields = "__all__"

class GoodsFilter(django_filters.rest_framework.FilterSet):class Meta:model = Goodsfields = ['pricemin','pricemax','is_hot']

from rest_framework import serializers
from user_operation.models import UserFav
from rest_framework.validators import UniqueTogetherValidatorclass UserFavSerializer(serializers.ModelSerializer):# 获取当前登录的用户user = serializers.HiddenField(default=serializers.CurrentUserDefault())class Meta:model = UserFav# validate实现唯一联合，一个商品只能收藏一次validators = [UniqueTogetherValidator(queryset=UserFav.objects.all(),fields=('user', 'goods'),# message的信息可以自定义message="已经收藏",)]# 收藏的时候需要返回商品的id，因为取消收藏的时候必须知道商品的id是多少fields = ("user","goods","id")

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserFav
from user_operation.serializers import UserFavSerializerclass UserFavViewset(viewsets.GenericViewSet,mixins.ListModelMixin,mixins.CreateModelMixin,mixins.DestroyModelMixin):"""用户收藏功能列表"""queryset = UserFav.objects.all()serializer_class = UserFavSerializer

from rest_framework import permissionsclass IsOwnerOrReadOnly(permissions.BasePermission):"""Object-level permission to only allow owners of an object to edit it.Assumes the model instance has an `owner` attribute."""def has_object_permission(self, request, view, obj):# Read permissions are allowed to any request,# so we'll always allow GET, HEAD or OPTIONS requests.if request.method in permissions.SAFE_METHODS:return True# Instance must have an attribute named `owner`.# obj为数据库的model,此处需要把owner修改为userreturn obj.user == request.user

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserFav
from user_operation.serializers import UserFavSerializer
from rest_framework.permissions import IsAuthenticated
from utils.permissions import IsOwnerOrReadOnly
from  rest_framework_jwt.authentication import JSONWebTokenAuthenticationclass UserFavViewset(viewsets.GenericViewSet,mixins.ListModelMixin,mixins.CreateModelMixin,mixins.DestroyModelMixin):"""用户收藏功能列表"""serializer_class = UserFavSerializer# permission是用来做权限判断的# IsAuthenticated为必须登录用户，IsOwnerOrReadOnly：必须是当前登录用户permission_classes = (IsAuthenticated,IsOwnerOrReadOnly)# auth用户验证authentication_classes = (JSONWebTokenAuthentication,)# 只能查看当前登录用户的收藏，不会获取所有用户的收藏def get_queryset(self):return UserFav.objects.filter(user=self.request.user)

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserFav
from user_operation.serializers import UserFavSerializer
from rest_framework.permissions import IsAuthenticated
from utils.permissions import IsOwnerOrReadOnly
from  rest_framework_jwt.authentication import JSONWebTokenAuthentication
from  rest_framework.authentication import SessionAuthenticationclass UserFavViewset(viewsets.GenericViewSet,mixins.ListModelMixin,mixins.CreateModelMixin,mixins.DestroyModelMixin):"""用户收藏功能列表"""# permission是用来做权限判断的# IsAuthenticated为必须登录用户，IsOwnerOrReadOnly：必须是当前登录用户permission_classes = (IsAuthenticated,IsOwnerOrReadOnly)serializer_class = UserFavSerializer# auth用户验证authentication_classes = (JSONWebTokenAuthentication,SessionAuthentication)# 搜索的字段lookup_field = "goods_id"# 只能查看当前登录用户的收藏，不会获取所有用户的收藏def get_queryset(self):return UserFav.objects.filter(user=self.request.user)

class UserDetailSerializer(serializers.ModelSerializer):"""用户详情序列化类"""class Meta:model = Userfields = ("name","birthday","gender","email","mobile")

from rest_framework import permissions
from rest_framework.authentication import SessionAuthentication
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from users.serializers import UserRegSerializer,UserDetailSerializerclass UserViewset(CreateModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):"""用户"""serializer_class = UserRegSerializerqueryset = User.objects.all()authentication_classes = (SessionAuthentication,JSONWebTokenAuthentication) # 浏览器里面添加session或者head里面添加token# permission_classes = (permissions.IsAuthenticated,) # 出现弹窗，需要登陆用户和密码# 序列化的选择# 1.用户注册(UserRegSerializer)，只返回username和mobile;会员中心(UserDetailSerializer)需要更多字段# 2.如果注册的使用userdetailSerializer，又会导致验证失败，所以需要动态的使用serializer，重构get_serializer_class方法def get_serializer_class(self):if self.action == "retrieve":return UserDetailSerializerelif self.action == "create":return UserRegSerializerreturn UserDetailSerializer# 动态权限配置# 1.用户注册的时候不应该有权限限制# 2.用户在获取用户详情信息的时候，需要登陆才行def get_permissions(self):if self.action == "retrieve":return [permissions.IsAuthenticated()]elif self.action == "create":return []return []# 注册完成后实现登录，把token返回回来def create(self, request, *args, **kwargs):serializer = self.get_serializer(data=request.data)serializer.is_valid(raise_exception=True)user = self.perform_create(serializer)# 通过User生成jwt token#  数据放在data中，先序列化，在取出返回给用户re_dict = serializer.datapayload = jwt_payload_handler(user)re_dict["token"] = jwt_encode_handler(payload)re_dict["name"] = user.name if user.name else user.usernameheaders = self.get_success_headers(serializer.data)return Response(re_dict, status=status.HTTP_201_CREATED, headers=headers)# 虽然继承了Retrieve可以获取用户详情，但是并不知道用户的id，所以要重写get_object方法# 重写get_object方法，就知道是哪个用户了def get_object(self):return self.request.userdef perform_create(self, serializer):# 返回的是UserRegSerializer中model的对象(也就是User)return serializer.save()

class UserViewset(CreateModelMixin, mixins.RetrieveModelMixin, mixins.UpdateModelMixin,viewsets.GenericViewSet):

from goods.serializers import GoodsSerializer
class UserFavDetailSerializer(serializers.ModelSerializer):"""用户收藏详情"""# 通过商品id获取收藏的商品，需要嵌套商品的序列化goods = GoodsSerializer()class Meta:model = UserFavfields = ("goods","id")

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserFav
from user_operation.serializers import UserFavSerializer,UserFavDetailSerializer
from rest_framework.permissions import IsAuthenticated
from utils.permissions import IsOwnerOrReadOnly
from  rest_framework_jwt.authentication import JSONWebTokenAuthentication
from  rest_framework.authentication import SessionAuthenticationclass UserFavViewset(viewsets.GenericViewSet,mixins.ListModelMixin,mixins.CreateModelMixin,mixins.RetrieveModelMixin,mixins.DestroyModelMixin):"""list:用户收藏功能列表create:收藏商品Retrieve:判断某个商品是否已经收藏delete:删除收藏商品"""# permission是用来做权限判断的# IsAuthenticated为必须登录用户，IsOwnerOrReadOnly：必须是当前登录用户permission_classes = (IsAuthenticated,IsOwnerOrReadOnly)# auth用户验证authentication_classes = (JSONWebTokenAuthentication,SessionAuthentication)# 搜索的字段lookup_field = "goods_id"# 动态选择serializerdef get_serializer_class(self):if self.action == "list":return UserFavDetailSerializerelif self.action == "create":return UserFavSerializerreturn UserFavSerializer# 只能查看当前登录用户的收藏，不会获取所有用户的收藏def get_queryset(self):return UserFav.objects.filter(user=self.request.user)

from user_operation.models import UserLeavingMessage
class LeavingMessageSerializer(serializers.ModelSerializer):# 获取当前登录的用户user = serializers.HiddenField(default=serializers.CurrentUserDefault())# 添加时间，read_only只返回，不提交add_time = serializers.DateTimeField(read_only=True, format="%Y-%m-%d %H:%M")class Meta:model = UserLeavingMessagefields = ("user","message_type","subject","message","file","id","add_time")

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserLeavingMessage
from user_operation.serializers import LeavingMessageSerializer
from rest_framework.permissions import IsAuthenticated
from utils.permissions import IsOwnerOrReadOnly
from  rest_framework_jwt.authentication import JSONWebTokenAuthentication
from  rest_framework.authentication import SessionAuthenticationclass LeavingMessageViewset(mixins.ListModelMixin, mixins.DestroyModelMixin, mixins.CreateModelMixin, viewsets.GenericViewSet):"""List:获取用户留言Create:添加留言Delete：删除留言功能"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = LeavingMessageSerializer# 只能看到自己的留言def get_queryset(self):return UserLeavingMessage.objects.filter(user=self.request.user)

from user_operation.models import UserAddress
class AddressSerializer(serializers.ModelSerializer):# 获取当前登录的用户user = serializers.HiddenField(default=serializers.CurrentUserDefault())# 添加时间，read_only只返回，不提交add_time = serializers.DateTimeField(read_only=True, format="%Y-%m-%d %H:%M")class Meta:model = UserAddressfields = ("id","user", "province", "city", "district", "address", "signer_name","signer_mobile", "add_time")

from rest_framework import viewsets
from rest_framework import mixinsfrom user_operation.models import UserAddress
from user_operation.serializers import AddressSerializer
from rest_framework.permissions import IsAuthenticated
from utils.permissions import IsOwnerOrReadOnly
from  rest_framework_jwt.authentication import JSONWebTokenAuthentication
from  rest_framework.authentication import SessionAuthenticationclass AddressViewset(viewsets.ModelViewSet):"""收货地址管理List：获取收货地址create:添加收货地址update:更新收货地址delete:删除收货地址"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = AddressSerializer# 只能看到自己的留言def get_queryset(self):return UserAddress.objects.filter(user=self.request.user)

from rest_framework import serializersfrom goods.models import Goods
from trade.models import ShoppingCartclass ShopCartSerializer(serializers.Serializer):# 获取当前登录的用户user = serializers.HiddenField(default=serializers.CurrentUserDefault())nums = serializers.IntegerField(required=True,label="数量",min_value=1,max_value=None,error_messages={"required":"请选择购买数量","min_value":"商品数量不能小于1",})goods = serializers.PrimaryKeyRelatedField(required=True,queryset=Goods.objects.all())def create(self, validated_data):# validated_data处理后的数据# 获取当前用户user = self.context["request"].usernums = validated_data["nums"]goods = validated_data["goods"]existed = ShoppingCart.objects.filter(user=user, goods=goods)# 如果购物车中有记录，现有数量+原来数量# 如果购物车车没有记录，就创建if existed:existed = existed[0]existed.nums += numsexisted.save()else:existed = ShoppingCart.objects.create(**validated_data)return existed

from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework.authentication import SessionAuthentication
from rest_framework_jwt.authentication import JSONWebTokenAuthenticationfrom trade.serializers import ShopCartSerializer
from trade.models import ShoppingCart
from utils.permissions import IsOwnerOrReadOnlyclass ShoppingCartViewset(viewsets.ModelViewSet):"""购物车功能list:获取购物车详情create:加入购物车delete:删除购物车记录"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = ShopCartSerializer# 返回当前用户购物车列表页def get_queryset(self):return ShoppingCart.objects.filter(user=self.request.user)

lookup_field = "goods_id"

def update(self, instance, validated_data):# 修改商品数量instance.nums = validated_data["nums"]instance.save()return instance

from rest_framework import serializers
from trade.models import ShoppingCart
from goods.serializers import GoodsSerializerclass ShopCartDetailSerializer(serializers.ModelSerializer):"""购物车详情信息"""# 一个购物车对应一个商品goods = GoodsSerializer(many=False)class Meta:model = ShoppingCartfields = "__all__"

def get_serializer_class(self):if self.action == "list":return ShopCartDetailSerializerelse:return ShopCartSerializer

from rest_framework import serializersfrom goods.models import Goods
from trade.models import OrderInfo,OrderGoods
from goods.serializers import GoodsSerializerclass OrderGoodsSerializer(serializers.ModelSerializer):# 订单详情中的商品信息goods = GoodsSerializer(many=False)class Meta:model = OrderGoodsfields = "__all__"class OrderDetailSerializer(serializers.ModelSerializer):# 订单详情goods = OrderGoodsSerializer(many=True)class Meta:model = OrderInfofields = "__all__"class OrderSerializer(serializers.ModelSerializer):# 获取当前登录的用户,界面不显示user,相当于read_onlyuser = serializers.HiddenField(default=serializers.CurrentUserDefault())# 生成订单的时候这些不用POSTpay_status = serializers.CharField(read_only=True)trade_no = serializers.CharField(read_only=True)order_sn = serializers.CharField(read_only=True)pay_time = serializers.DateTimeField(read_only=True)def generate_order_sn(self):# 生成订单号，当前时间 + userid + 两位随机数import timefrom random import Randomrandom_ins = Random()order_sn = "{time_str}{user_id}{random_str}".format(time_str=time.strftime("%Y%m%d%H%M%S"),user_id=self.context["request"].user.id,random_str=random_ins.randint(10,99))return order_sndef validate(self, attrs):# 实例化上面方法，validate中添加order_sn，在view中perform_create方法里saveattrs["order_sn"]=self.generate_order_sn()return attrsclass Meta:model = OrderInfofields = "__all__"

from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework.authentication import SessionAuthentication
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework import mixinsfrom trade.serializers import OrderSerializer,OrderDetailSerializer
from trade.models import OrderInfo,OrderGoods
from utils.permissions import IsOwnerOrReadOnlyclass OrderViewset(mixins.ListModelMixin, mixins.CreateModelMixin, mixins.RetrieveModelMixin,mixins.DestroyModelMixin, viewsets.GenericViewSet):# 此处不使用ModelViewSet，因为订单不能修改，不能使用UpdateModelMixin"""订单详情List:获取个人订单delete:删除订单create:新增订单Retrieve:订单详情"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = OrderSerializer# 获取当前用户订单def get_queryset(self):return OrderInfo.objects.filter(user= self.request.user)# 动态获取def get_serializer_class(self):if self.action == "retrieve":return OrderDetailSerializerreturn OrderSerializer# 在订单提交保存之前还需要多两步步骤，所以这里自定义perform_create方法# 1.将购物车中的商品保存到OrderGoods中# 2.清空购物车def perform_create(self, serializer):# save之前生成订单号order = serializer.save()shop_carts = ShoppingCart.objects.filter(user=self.request.user)for shop_cart in shop_carts:order_goods = OrderGoods()order_goods.goods = shop_cart.goodsorder_goods.goods_num = shop_cart.numsorder_goods.order = orderorder_goods.save()# 清空购物车
            shop_cart.delete()return order

from datetime import datetime
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
from base64 import b64encode, b64decode
from urllib.parse import quote_plus
from urllib.parse import urlparse, parse_qs
from urllib.request import urlopen
from base64 import decodebytes, encodebytesimport jsonclass AliPay(object):"""支付宝支付接口"""def __init__(self, appid, app_notify_url, app_private_key_path,alipay_public_key_path, return_url, debug=False):self.appid = appidself.app_notify_url = app_notify_url# 应用私钥self.app_private_key_path = app_private_key_pathself.app_private_key = Noneself.return_url = return_urlwith open(self.app_private_key_path) as fp:self.app_private_key = RSA.importKey(fp.read())# 阿里公钥self.alipay_public_key_path = alipay_public_key_pathwith open(self.alipay_public_key_path) as fp:self.alipay_public_key = RSA.import_key(fp.read())if debug is True:self.__gateway = "https://openapi.alipaydev.com/gateway.do"else:self.__gateway = "https://openapi.alipay.com/gateway.do"def direct_pay(self, subject, out_trade_no, total_amount, return_url=None, **kwargs):# 请求参数biz_content = {"subject": subject,"out_trade_no": out_trade_no,"total_amount": total_amount,"product_code": "FAST_INSTANT_TRADE_PAY",# "qr_pay_mode":4
        }# 允许传递更多参数，放到biz_content
        biz_content.update(kwargs)data = self.build_body("alipay.trade.page.pay", biz_content, self.return_url)return self.sign_data(data)def build_body(self, method, biz_content, return_url=None):# 公共请求参数data = {"app_id": self.appid,"method": method,"charset": "utf-8","sign_type": "RSA2","timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),"version": "1.0","biz_content": biz_content}if return_url is not None:data["notify_url"] = self.app_notify_urldata["return_url"] = self.return_urlreturn datadef sign_data(self, data):# 签名data.pop("sign", None)# 排序后的字符串unsigned_items = self.ordered_data(data)# 排完序后拼接起来unsigned_string = "&".join("{0}={1}".format(k, v) for k, v in unsigned_items)# 得到签名的字符串sign = self.sign(unsigned_string.encode("utf-8"))# 对url进行处理quoted_string = "&".join("{0}={1}".format(k, quote_plus(v)) for k, v in unsigned_items)# 获得最终的订单信息字符串signed_string = quoted_string + "&sign=" + quote_plus(sign)return signed_stringdef ordered_data(self, data):# 参数传进来一定要排序complex_keys = []for key, value in data.items():if isinstance(value, dict):complex_keys.append(key)# 将字典类型的数据dump出来for key in complex_keys:data[key] = json.dumps(data[key], separators=(',', ':'))return sorted([(k, v) for k, v in data.items()])def sign(self, unsigned_string):# 开始计算签名key = self.app_private_key# 签名对象signer = PKCS1_v1_5.new(key)# 生成签名signature = signer.sign(SHA256.new(unsigned_string))# base64 编码，转换为unicode表示并移除回车sign = encodebytes(signature).decode("utf8").replace("\n", "")return signdef _verify(self, raw_content, signature):# 开始计算签名key = self.alipay_public_keysigner = PKCS1_v1_5.new(key)digest = SHA256.new()digest.update(raw_content.encode("utf8"))if signer.verify(digest, decodebytes(signature.encode("utf8"))):return Truereturn Falsedef verify(self, data, signature):if "sign_type" in data:sign_type = data.pop("sign_type")# 排序后的字符串unsigned_items = self.ordered_data(data)message = "&".join(u"{}={}".format(k, v) for k, v in unsigned_items)return self._verify(message, signature)if __name__ == "__main__":return_url = 'http://127.0.0.1:8001/?charset=utf-8&out_trade_no=201702021224&method=alipay.trade.page.pay.return&total_amount=0.01&sign=R01hGeanJ6GUdufKFUQhRzYbv2h%2F8PwvhFykotT7E6UDebrarj9xSt8YgPkWxq%2F3yYlGg1aWtc88yuwL2rI40s6R1AYpv8FFTwHn0%2FRcQZAvq1D8hKo8JXXpyMaKbEzTqPsUtAA8jWOfRZiUqAJxBeLM0G4hawK3qu6x4MyKH%2BLg3uFuxhm9smlSgxwKrHQ84WfdQw6WUEDVG56FX8CG2hWVgO5X7CXM6L0ZkrLYJij254%2BcA9cMHuTacpl35otUbYggoDZHpm5dt2fEKnmRwkzY0Cja30kYcc6w%2FAWCQfetIx0W0psnLKTIhnV9MDQbtqbHGbWWI0I8GOHTNkS9Zg%3D%3D&trade_no=2019062022001459821000056107&auth_app_id=2016092900626681&version=1.0&app_id=2016092900626681&sign_type=RSA2&seller_id=2088102177859523&timestamp=2019-06-20+10%3A36%3A58'o = urlparse(return_url)query = parse_qs(o.query)processed_query = {}ali_sign = query.pop("sign")[0]# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path="../trade/keys/private_2048.txt",# 支付宝的公钥alipay_public_key_path="../trade/keys/alipay_key_2048.txt",  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")for key, value in query.items():processed_query[key] = value[0]print (alipay.verify(processed_query, ali_sign))url = alipay.direct_pay(# 订单标题subject="测试订单",# 我们商户自行生成的订单号out_trade_no="201702021224",# 订单金额total_amount=0.01,# 成功付款后跳转到的页面，return_url同步的urlreturn_url="http://47.107.36.249:8001/alipay/return/",)re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=url)print(re_url)

import json
from datetime import datetime
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
from base64 import b64encode, b64decode
from urllib.parse import quote_plus
from urllib.parse import urlparse, parse_qs
from urllib.request import urlopen
from base64 import decodebytes, encodebytesclass AliPay(object):"""支付宝支付接口"""def __init__(self, appid, app_notify_url, app_private_key_path,alipay_public_key_path, return_url, debug=False):self.appid = appidself.app_notify_url = app_notify_url# 应用私钥self.app_private_key_path = app_private_key_pathself.app_private_key = Noneself.return_url = return_urlwith open(self.app_private_key_path) as fp:self.app_private_key = RSA.importKey(fp.read())# 阿里公钥self.alipay_public_key_path = alipay_public_key_pathwith open(self.alipay_public_key_path) as fp:self.alipay_public_key = RSA.import_key(fp.read())if debug is True:self.__gateway = "https://openapi.alipaydev.com/gateway.do"else:self.__gateway = "https://openapi.alipay.com/gateway.do"def direct_pay(self, subject, out_trade_no, total_amount, return_url=None, **kwargs):# 请求参数biz_content = {"subject": subject,"out_trade_no": out_trade_no,"total_amount": total_amount,"product_code": "FAST_INSTANT_TRADE_PAY",# "qr_pay_mode":4
        }# 允许传递更多参数，放到biz_content
        biz_content.update(kwargs)data = self.build_body("alipay.trade.page.pay", biz_content, self.return_url)return self.sign_data(data)def build_body(self, method, biz_content, return_url=None):# 公共请求参数data = {"app_id": self.appid,"method": method,"charset": "utf-8","sign_type": "RSA2","timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),"version": "1.0","biz_content": biz_content}if return_url is not None:data["notify_url"] = self.app_notify_urldata["return_url"] = self.return_urlreturn datadef sign_data(self, data):# 签名data.pop("sign", None)# 排序后的字符串unsigned_items = self.ordered_data(data)# 排完序后拼接起来unsigned_string = "&".join("{0}={1}".format(k, v) for k, v in unsigned_items)# 得到签名的字符串sign = self.sign(unsigned_string.encode("utf-8"))# 对url进行处理quoted_string = "&".join("{0}={1}".format(k, quote_plus(v)) for k, v in unsigned_items)# 获得最终的订单信息字符串signed_string = quoted_string + "&sign=" + quote_plus(sign)return signed_stringdef ordered_data(self, data):# 参数传进来一定要排序complex_keys = []for key, value in data.items():if isinstance(value, dict):complex_keys.append(key)# 将字典类型的数据dump出来for key in complex_keys:data[key] = json.dumps(data[key], separators=(',', ':'))return sorted([(k, v) for k, v in data.items()])def sign(self, unsigned_string):# 开始计算签名key = self.app_private_key# 签名对象signer = PKCS1_v1_5.new(key)# 生成签名signature = signer.sign(SHA256.new(unsigned_string))# base64 编码，转换为unicode表示并移除回车sign = encodebytes(signature).decode("utf8").replace("\n", "")return signdef _verify(self, raw_content, signature):# 开始计算签名key = self.alipay_public_keysigner = PKCS1_v1_5.new(key)digest = SHA256.new()digest.update(raw_content.encode("utf8"))if signer.verify(digest, decodebytes(signature.encode("utf8"))):return Truereturn Falsedef verify(self, data, signature):if "sign_type" in data:sign_type = data.pop("sign_type")# 排序后的字符串unsigned_items = self.ordered_data(data)message = "&".join(u"{}={}".format(k, v) for k, v in unsigned_items)return self._verify(message, signature)if __name__ == "__main__":return_url = 'http://47.107.36.249:8001/alipay/return/?charset=utf-8&out_trade_no=201702021224&method=alipay.trade.page.pay.return&total_amount=0.01&sign=R01hGeanJ6GUdufKFUQhRzYbv2h%2F8PwvhFykotT7E6UDebrarj9xSt8YgPkWxq%2F3yYlGg1aWtc88yuwL2rI40s6R1AYpv8FFTwHn0%2FRcQZAvq1D8hKo8JXXpyMaKbEzTqPsUtAA8jWOfRZiUqAJxBeLM0G4hawK3qu6x4MyKH%2BLg3uFuxhm9smlSgxwKrHQ84WfdQw6WUEDVG56FX8CG2hWVgO5X7CXM6L0ZkrLYJij254%2BcA9cMHuTacpl35otUbYggoDZHpm5dt2fEKnmRwkzY0Cja30kYcc6w%2FAWCQfetIx0W0psnLKTIhnV9MDQbtqbHGbWWI0I8GOHTNkS9Zg%3D%3D&trade_no=2019062022001459821000056107&auth_app_id=2016092900626681&version=1.0&app_id=2016092900626681&sign_type=RSA2&seller_id=2088102177859523&timestamp=2019-06-20+10%3A36%3A58'o = urlparse(return_url)query = parse_qs(o.query)processed_query = {}ali_sign = query.pop("sign")[0]# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path="../trade/keys/private_2048.txt",# 支付宝的公钥alipay_public_key_path="../trade/keys/alipay_key_2048.txt",  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")for key, value in query.items():processed_query[key] = value[0]print (alipay.verify(processed_query, ali_sign))url = alipay.direct_pay(# 订单标题subject="测试订单",# 我们商户自行生成的订单号out_trade_no="201702021226",# 订单金额total_amount=0.01,# 成功付款后跳转到的页面，return_url同步的urlreturn_url="http://47.107.36.249:8001/alipay/return/",)re_url = "https://openapi.alipaydev.com/gateway.do?{data}".format(data=url)print(re_url)

from rest_framework.views import APIView
from utils.alipay import AliPay
from Shop.settings import private_key_path,ali_pub_key_path
from datetime import datetime
from rest_framework.response import Response
class AlipayView(APIView):def get(self,request):"""处理支付宝的return_url返回:param requeat::return:"""processed_dict = { }#  获取GET中的数据for key, value in request.GET.items():processed_dict[key] = value# 取出sign和空数据sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)# 这里可以不做操作.因为不管发不发return url, notify url都会修改订单状态.if verify_re == True:order_sn = processed_dict.get('out_trade_no',None)trade_no = processed_dict.get('trade_no', None)trade_status = processed_dict.get('trade_status', None)existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()return Response('success')def post(self,request):"""处理支付宝的notify_url:param request::return:"""# 存放post里面所有的数据processed_dict = { }# 取出post里面的数据,数据在request.POST里面for key, value in request.POST.items():processed_dict[key] = value# 把sign和空数据都需要pop掉，阿里文档有说明sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)if verify_re == True:# 商户订单号:原支付请求的商户订单号order_sn = processed_dict.get('out_trade_no',None)# 支付宝交易号:    支付宝交易凭证号trade_no = processed_dict.get('trade_no', None)# 交易状态trade_status = processed_dict.get('trade_status', None)# 查询数据库中订单记录existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:# 更新订单状态existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()# 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息return Response('success')

from rest_framework import serializersfrom goods.models import Goods
from trade.models import ShoppingCart,OrderInfo,OrderGoods
from goods.serializers import GoodsSerializer
from utils.alipay import AliPay
from Shop.settings import private_key_path,ali_pub_key_pathclass ShopCartDetailSerializer(serializers.ModelSerializer):"""购物车详情信息"""# 一个购物车对应一个商品goods = GoodsSerializer(many=False)class Meta:model = ShoppingCartfields = "__all__"class ShopCartSerializer(serializers.Serializer):# 获取当前登录的用户user = serializers.HiddenField(default=serializers.CurrentUserDefault())nums = serializers.IntegerField(required=True,label="数量",min_value=1,max_value=None,error_messages={"required":"请选择购买数量","min_value":"商品数量不能小于1",})goods = serializers.PrimaryKeyRelatedField(required=True,queryset=Goods.objects.all())def create(self, validated_data):# validated_data处理后的数据# 获取当前用户user = self.context["request"].usernums = validated_data["nums"]goods = validated_data["goods"]existed = ShoppingCart.objects.filter(user=user, goods=goods)# 如果购物车中有记录，数量+1# 如果购物车车没有记录，就创建if existed:existed = existed[0]existed.nums += numsexisted.save()else:existed = ShoppingCart.objects.create(**validated_data)return existeddef update(self, instance, validated_data):# 修改商品数量instance.nums = validated_data["nums"]instance.save()return instanceclass OrderGoodsSerializer(serializers.ModelSerializer):# 订单详情中的商品信息goods = GoodsSerializer(many=False)class Meta:model = OrderGoodsfields = "__all__"class OrderDetailSerializer(serializers.ModelSerializer):# 订单详情goods = OrderGoodsSerializer(many=True)# 支付订单的url# 参考网址：https://www.django-rest-framework.org/api-guide/fields/#serializermethodfieldalipay_url = serializers.SerializerMethodField(read_only=True)def get_alipay_url(self, obj):# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path = private_key_path,# 支付宝的公钥alipay_public_key_path = ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/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_urlclass Meta:model = OrderInfofields = "__all__"class OrderSerializer(serializers.ModelSerializer):# 获取当前登录的用户,界面不显示user,相当于read_onlyuser = serializers.HiddenField(default=serializers.CurrentUserDefault())# 生成订单的时候这些不用POST（不提交，服务器生成返回给用户）pay_status = serializers.CharField(read_only=True)trade_no = serializers.CharField(read_only=True)order_sn = serializers.CharField(read_only=True)pay_time = serializers.DateTimeField(read_only=True)# 支付订单的url# 灵活字段，可以自己写函数逻辑，不用依赖数据表的字段，drf参考网址：https://www.django-rest-framework.org/api-guide/fields/#serializermethodfieldalipay_url = serializers.SerializerMethodField(read_only=True)def get_alipay_url(self, obj):# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path = private_key_path,# 支付宝的公钥alipay_public_key_path = ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/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_urldef generate_order_sn(self):# 生成订单号，当前时间 + userid + 两位随机数import timefrom random import Randomrandom_ins = Random()order_sn = "{time_str}{user_id}{random_str}".format(time_str=time.strftime("%Y%m%d%H%M%S"),user_id=self.context["request"].user.id,random_str=random_ins.randint(10,99))return order_sndef validate(self, attrs):# 实例化上面方法，validate中添加order_sn，在view中perform_create方法里saveattrs["order_sn"]=self.generate_order_sn()return attrsclass Meta:model = OrderInfofields = "__all__"

    response = redirect("index")response.set_cookie("nextPath", "pay", max_age=2)return response
else:response = redirect("index")return response

from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework.authentication import SessionAuthentication
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework import mixinsfrom trade.serializers import ShopCartSerializer,ShopCartDetailSerializer,OrderSerializer,OrderDetailSerializer
from trade.models import ShoppingCart,OrderInfo,OrderGoods
from utils.permissions import IsOwnerOrReadOnlyclass ShoppingCartViewset(viewsets.ModelViewSet):"""购物车功能list:获取购物车详情create:加入购物车delete:删除购物车记录"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = ShopCartSerializer# 搜索的字段lookup_field = "goods_id"def get_serializer_class(self):if self.action == "list":return ShopCartDetailSerializerelse:return ShopCartSerializer# 返回当前用户购物车列表页def get_queryset(self):return ShoppingCart.objects.filter(user=self.request.user)class OrderViewset(mixins.ListModelMixin, mixins.CreateModelMixin, mixins.RetrieveModelMixin,mixins.DestroyModelMixin, viewsets.GenericViewSet):# 此处不使用ModelViewSet，因为订单不能修改，不能使用UpdateModelMixin"""订单详情List:获取个人订单delete:删除订单create:新增订单Retrieve:订单详情"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = OrderSerializer# 获取当前用户订单def get_queryset(self):return OrderInfo.objects.filter(user= self.request.user)# 动态获取def get_serializer_class(self):if self.action == "retrieve":return OrderDetailSerializerreturn OrderSerializer# 在订单提交保存之前还需要多两步步骤，所以这里自定义perform_create方法# 1.将购物车中的商品保存到OrderGoods中# 2.清空购物车def perform_create(self, serializer):# save之前生成订单号order = serializer.save()shop_carts = ShoppingCart.objects.filter(user=self.request.user)for shop_cart in shop_carts:order_goods = OrderGoods()order_goods.goods = shop_cart.goodsorder_goods.goods_num = shop_cart.numsorder_goods.order = orderorder_goods.save()# 清空购物车
            shop_cart.delete()return orderfrom rest_framework.views import APIView
from utils.alipay import AliPay
from Shop.settings import private_key_path,ali_pub_key_path
from datetime import datetime
from rest_framework.response import Response
from django.shortcuts import redirect
class AlipayView(APIView):def get(self,request):"""处理支付宝的return_url返回:param requeat::return:"""processed_dict = { }#  获取GET中的数据for key, value in request.GET.items():processed_dict[key] = value# 取出sign和空数据sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/",)# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)# 这里可以不做操作.因为不管发不发return url, notify url都会修改订单状态.if verify_re == True:order_sn = processed_dict.get('out_trade_no',None)trade_no = processed_dict.get('trade_no', None)trade_status = processed_dict.get('trade_status', None)existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()response = redirect("/index/#/app/home/member/order")# response = redirect("index")# response.set_cookie("nextPath", "pay", max_age=2)return responseelse:response = redirect("index")return responsedef post(self,request):"""处理支付宝的notify_url:param request::return:"""# 存放post里面所有的数据processed_dict = { }# 取出post里面的数据,数据在request.POST里面for key, value in request.POST.items():processed_dict[key] = value# 把sign和空数据都需要pop掉，阿里文档有说明sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)if verify_re == True:# 商户订单号:原支付请求的商户订单号order_sn = processed_dict.get('out_trade_no',None)# 支付宝交易号:    支付宝交易凭证号trade_no = processed_dict.get('trade_no', None)# 交易状态trade_status = processed_dict.get('trade_status', None)# 查询数据库中订单记录existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:# 更新订单状态existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()# 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息return Response('success')

from rest_framework.response import Response
class GoodsListViewSet(mixins.ListModelMixin,mixins.RetrieveModelMixin,viewsets.GenericViewSet):"""商品列表页，分页，过滤器，搜索，排序"""queryset = Goods.objects.all().order_by('goods__category_id')   # queryset不可以更改serializer_class = GoodsSerializer                              # 引用序列化相应的对象pagination_class = GooodsPagination                             # 引用商品列表自定义分页# authentication_classes = (TokenAuthentication,)filter_backends = (DjangoFilterBackend,filters.SearchFilter,filters.OrderingFilter) # 过滤器，搜索，排序# filter_fields = ('name', 'market_price')filter_class = GoodsFilter #过滤精确字段search_fields = ('name', 'goods_brief','goods_desc') # 搜索字段ordering_fields = ('sold_num', 'shop_price') # 排序字段# 商品数+1def retrieve(self, request, *args, **kwargs):instance = self.get_object()instance.click_num += 1instance.save()serializer = self.get_serializer(instance)return Response(serializer.data)

class UserFavViewset(viewsets.GenericViewSet, mixins.ListModelMixin, mixins.CreateModelMixin, mixins.DestroyModelMixin):'''用户收藏'''#permission是用来做权限判断的# IsAuthenticated：必须登录用户；IsOwnerOrReadOnly：必须是当前登录的用户permission_classes = (IsAuthenticated,IsOwnerOrReadOnly)#auth使用来做用户认证的authentication_classes = (JSONWebTokenAuthentication,SessionAuthentication)#搜索的字段lookup_field = 'goods_id'#动态选择serializerdef get_serializer_class(self):if self.action == "list":return UserFavDetailSerializerelif self.action == "create":return UserFavSerializerreturn UserFavSerializerdef get_queryset(self):#只能查看当前登录用户的收藏，不会获取所有用户的收藏return UserFav.objects.filter(user=self.request.user)# 用户收藏的商品数量+1def perform_create(self, serializer):instance = serializer.save()# 这里instance相当于UserFav model，通过它找到goodsgoods = instance.goodsgoods.fav_num += 1goods.save()

class ShoppingCartViewset(viewsets.ModelViewSet):"""购物车功能list:获取购物车详情create:加入购物车delete:删除购物车记录"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = ShopCartSerializer# 搜索的字段lookup_field = "goods_id"def get_serializer_class(self):if self.action == "list":return ShopCartDetailSerializerelse:return ShopCartSerializer# 返回当前用户购物车列表页def get_queryset(self):return ShoppingCart.objects.filter(user=self.request.user)# 库存数-1,购物车数+1def perform_create(self, serializer):shop_cart = serializer.save()goods = shop_cart.goodsgoods.goods_num -= shop_cart.numsgoods.save()# 库存数+1，删除购物车def perform_destroy(self, instance):goods = instance.goodsgoods.goods_num += instance.numsgoods.save()instance.delete()# 更新库存数,修改可能是增加也可能是减少def perform_update(self, serializer):# 首先获取修改之前的库存数量existed_record = ShoppingCart.objects.get(serializer.instance.id)# 先保存之前的数据existed_nums(存在购买记录)existed_nums = existed_record.numssaved_record = serializer.save()# 数量变化nums = saved_record.nums - existed_numsgoods = saved_record.goodsgoods.goods_num -= numsgoods.save()

class OrderViewset(mixins.ListModelMixin, mixins.CreateModelMixin, mixins.RetrieveModelMixin,mixins.DestroyModelMixin, viewsets.GenericViewSet):# 此处不使用ModelViewSet，因为订单不能修改，不能使用UpdateModelMixin"""订单详情List:获取个人订单delete:删除订单create:新增订单Retrieve:订单详情"""permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)serializer_class = OrderSerializer# 获取当前用户订单def get_queryset(self):return OrderInfo.objects.filter(user= self.request.user)# 动态获取def get_serializer_class(self):if self.action == "retrieve":return OrderDetailSerializerreturn OrderSerializer# 在订单提交保存之前还需要多两步步骤，所以这里自定义perform_create方法# 1.将购物车中的商品保存到OrderGoods中# 2.清空购物车def perform_create(self, serializer):# save之前生成订单号order = serializer.save()shop_carts = ShoppingCart.objects.filter(user=self.request.user)for shop_cart in shop_carts:order_goods = OrderGoods()order_goods.goods = shop_cart.goodsorder_goods.goods_num = shop_cart.numsorder_goods.order = orderorder_goods.save()# 清空购物车
            shop_cart.delete()return orderfrom rest_framework.views import APIView
from utils.alipay import AliPay
from Shop.settings import private_key_path,ali_pub_key_path
from datetime import datetime
from rest_framework.response import Response
from django.shortcuts import redirect
class AlipayView(APIView):def get(self,request):"""处理支付宝的return_url返回:param requeat::return:"""processed_dict = { }#  获取GET中的数据for key, value in request.GET.items():processed_dict[key] = value# 取出sign和空数据sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/",)# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)# 这里可以不做操作.因为不管发不发return url, notify url都会修改订单状态.if verify_re == True:order_sn = processed_dict.get('out_trade_no',None)trade_no = processed_dict.get('trade_no', None)trade_status = processed_dict.get('trade_status', None)existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()response = redirect("/index/#/app/home/member/order")# response = redirect("index")# response.set_cookie("nextPath", "pay", max_age=2)return responseelse:response = redirect("index")return responsedef post(self,request):"""处理支付宝的notify_url:param request::return:"""# 存放post里面所有的数据processed_dict = { }# 取出post里面的数据,数据在request.POST里面for key, value in request.POST.items():processed_dict[key] = value# 把sign和空数据都需要pop掉，阿里文档有说明sign =processed_dict.pop("sign",None)# 测试用例alipay = AliPay(# 沙箱里面的appid值appid="2016092900626681",# notify_url是异步的urlapp_notify_url="http://47.107.36.249:8001/alipay/return/",# 我们自己商户的密钥app_private_key_path=private_key_path,# 支付宝的公钥alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,# debug为true时使用沙箱的url。如果不是用正式环境的urldebug=True,  # 默认False,return_url="http://47.107.36.249:8001/alipay/return/")# 进行验证，是否为支付宝请求过来的数据verify_re = alipay.verify(processed_dict, sign)if verify_re == True:# 商户订单号:原支付请求的商户订单号order_sn = processed_dict.get('out_trade_no',None)# 支付宝交易号:    支付宝交易凭证号trade_no = processed_dict.get('trade_no', None)# 交易状态trade_status = processed_dict.get('trade_status', None)# 查询数据库中订单记录existed_orders = OrderInfo.objects.filter(order_sn=order_sn)for existed_order in existed_orders:# 订单商品项,OrderInfo反向取OrderGoods，通过related_name="goods"找到OrderGoods对象order_goods = existed_order.goods.all()for order_good in order_goods:goods = order_good.goodsgoods.sold_num += order_good.goods_numgoods.save()# 更新订单状态existed_order.pay_status = trade_statusexisted_order.trade_no = trade_noexisted_order.pay_time = datetime.now()existed_order.save()# 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息return Response('success')