Django序列化&django REST framework

from goods.base_views import Goodslistview

url(r'^goods/$',Goodslistview.as_view(),name='goods_list'),

from datetime import datetime

from django.db import models
from DjangoUeditor.models import UEditorField

class 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_name

    def __str__(self):
        return self.name

from datetime import datetime

from 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_name

    def __str__(self):
        return self.name


class 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_name
        db_table = "goods_goodsbrand"

    def __str__(self):
        return self.name


class 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_name

    def __str__(self):
        return self.name


class 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_name

    def __str__(self):
        return self.goods.name


class 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_name

    def __str__(self):
        return self.goods.name


class 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_name

    def __str__(self):
        return self.goods.name


class 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_name

    def __str__(self):
        return self.keywords

from datetime import datetime

from django.db import models
from users.models import UserProfile

from 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_name
        unique_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_name

    def __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_name

    def __str__(self):
        return str(self.order.order_sn)

from datetime import datetime

from 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 Goods


class 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_name
        unique_together = ("user", "goods")

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


class 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_name

    def __str__(self):
        return self.subject


class 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_name

    def __str__(self):
        return self.address

from datetime import datetime

from 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_name

    def __str__(self):
        return self.username


class 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_name

    def __str__(self):
        return self.code

from goods.serializers import GoodsSerializer
from rest_framework import generics
from goods.models import Goods
from rest_framework.pagination import PageNumberPagination

class GooodsPagination(PageNumberPagination):
    page_size = 10 # 每页显示条数
    page_size_query_param = 'page_size'
    page_query_param = 'p' # 页码名字
    max_page_size = 10000 # 每页最大显示条数

class GoodsList(generics.ListAPIView):
    queryset = Goods.objects.all().order_by('goods__category_id') # queryset不可以更改
    serializer_class = GoodsSerializer
    pagination_class = GooodsPagination

注释掉 'PAGE_SIZE': 10,

from rest_framework import serializers
from goods.models import Goods,GoodsCategory

class GoodsCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class GoodsSerializer(serializers.ModelSerializer):
    category = GoodsCategorySerializer()    # category为外键字段，实例化操作
    class Meta:
        model = Goods
        # fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')
        fields = "__all__"

from django.conf.urls import url
from goods.views import GoodsListViewSet
goods_list = GoodsListViewSet.as_view({
    'get': 'list',
})
urlpatterns = [
    # 商品展示url
    url(r'^goods/$',goods_list,name='goods_list'),
]

from goods.serializers import GoodsSerializer
from goods.models import Goods
from rest_framework.pagination import PageNumberPagination
from rest_framework import viewsets
from rest_framework import mixins

class GooodsPagination(PageNumberPagination):
    page_size = 10 # 每页显示条数
    page_size_query_param = 'page_size'
    page_query_param = 'p' # 页码名字
    max_page_size = 10000 # 每页最大显示条数

class GoodsListViewSet(mixins.ListModelMixin,viewsets.GenericViewSet): # 继承ViewSet类
    queryset = Goods.objects.all().order_by('goods__category_id') # queryset不可以更改
    serializer_class = GoodsSerializer
    pagination_class = GooodsPagination

from rest_framework import serializers
from goods.models import Goods,GoodsCategory

class GoodsCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class GoodsSerializer(serializers.ModelSerializer):
    category = GoodsCategorySerializer()    # category为外键字段，实例化操作
    class Meta:
        model = Goods
        # fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')
        fields = "__all__"

from django.conf.urls import url,include
from goods.views import GoodsListViewSet
from rest_framework.routers import DefaultRouter

# goods_list = GoodsListViewSet.as_view({
#     'get': 'list',
# })

router = DefaultRouter()

# 配置goods的url
router.register(r'goods', GoodsListViewSet)

urlpatterns = [
    url(r'^', include(router.urls)),

    # 商品展示url
    # url(r'^goods/$',goods_list,name='goods_list'),
]

from goods.serializers import GoodsSerializer
from goods.models import Goods
from rest_framework.pagination import PageNumberPagination
from rest_framework import viewsets
from rest_framework import mixins

class GooodsPagination(PageNumberPagination):
    page_size = 10 # 每页显示条数
    page_size_query_param = 'page_size'
    page_query_param = 'p' # 页码名字
    max_page_size = 10000 # 每页最大显示条数

class GoodsListViewSet(mixins.ListModelMixin,viewsets.GenericViewSet): # 继承ViewSet类
    queryset = Goods.objects.all().order_by('goods__category_id') # queryset不可以更改
    serializer_class = GoodsSerializer
    pagination_class = GooodsPagination

from rest_framework import serializers
from goods.models import Goods,GoodsCategory

class GoodsCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class GoodsSerializer(serializers.ModelSerializer):
    category = GoodsCategorySerializer()    # category为外键字段，实例化操作
    class Meta:
        model = Goods
        # fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')
        fields = "__all__"

apps添加：
'django_filters',

import django_filters
from goods.models import Goods

class GoodsFilter(django_filters.rest_framework.FilterSet):
    """
    自定义过滤类
    """
    price_min = django_filters.NumberFilter(field_name='shop_price', lookup_expr='gte')  #新版已改成field_name，使用name会报错
    price_max = django_filters.NumberFilter(field_name='shop_price', lookup_expr='lte')

    class Meta:
        model = Goods
        fields = ['price_min', 'price_max']

from rest_framework import serializers
from goods.models import Goods,GoodsCategory

class GoodsCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class GoodsSerializer(serializers.ModelSerializer):
    category = GoodsCategorySerializer()    # category为外键字段，实例化操作
    class Meta:
        model = Goods
        # fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')
        fields = "__all__"

import django_filters
from goods.models import Goods

class GoodsFilter(django_filters.rest_framework.FilterSet):
    """
    商品的过滤类
    """
    pricemin = django_filters.NumberFilter(field_name="shop_price",help_text ='最低价格',lookup_expr='gte') # 新版已改成field_name，使用name会报错
    pricemax = django_filters.NumberFilter(field_name="shop_price",help_text ='最高价格',lookup_expr='lte')
    name = django_filters.CharFilter(field_name='name',lookup_expr='icontains')
    class Meta:
        model = Goods
        fields = ['pricemin','pricemax','name']

from goods.views import GoodsListViewSet,GoodsCategoryViewSet 
# 配置goodscategorys的url
router.register(r'goodscategorys', GoodsCategoryViewSet,base_name='goodscategorys')

from goods.serializers import GoodsSerializer,CategorySerializer
from goods.models import Goods,GoodsCategory
class CategoryViewSet(mixins.ListModelMixin,mixins.RetrieveModelMixin,viewsets.GenericViewSet):
    """
    list:商品分类列表数据
    retrieve:获取商品分类详情
    """
    queryset = GoodsCategory.objects.filter(category_type=1)  # 取出所有对象
    serializer_class = CategorySerializer                     # 序列化相应的对象

from rest_framework import serializers
from goods.models import Goods,GoodsCategory
class CategorySerializer3(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class CategorySerializer2(serializers.ModelSerializer):
    sub_cat = CategorySerializer3(many=True)
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class CategorySerializer(serializers.ModelSerializer):
    sub_cat = CategorySerializer2(many=True)
    class Meta:
        model = GoodsCategory
        fields = "__all__"

let host = 'http://shop.projectsedu.com';
let localhost = 'http://127.0.0.1:8000';

# app设置到settings当中
'corsheaders',

# 添加中间件，放在CsrfViewMiddleware前面，可以放在第一个
'corsheaders.middleware.CorsMiddleware',

# 直接允许所有主机跨域，写在中间件下面即可
CORS_ORIGIN_ALLOW_ALL = True # 默认为False

# list.vue 
if(this.pageType=='search'){
  getGoods({
    search: this.searchWord, //搜索关键词
  }).then((response)=> {
    this.listData = response.data.results;
    this.proNum = response.data.count;
  }).catch(function (error) {
    console.log(error);
  });
}else {
  getGoods({
    page: this.curPage, //当前页码
    top_category: this.top_category, //商品类型
    ordering: this.ordering, //排序类型
    pricemin: this.pricemin, //价格最低 默认为‘’ 即为不选价格区间
    pricemax: this.pricemax // 价格最高 默认为‘’
  }).then((response)=> {

    this.listData = response.data.results;
    this.proNum = response.data.count;
  }).catch(function (error) {
    console.log(error);
  });
}

from goods.serializers import GoodsSerializer,CategorySerializer
from rest_framework import generics
from goods.models import Goods,GoodsCategory
from rest_framework.pagination import PageNumberPagination
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework import viewsets
from rest_framework import filters
from rest_framework import mixins
from goods.filters import GoodsFilter

class GooodsPagination(PageNumberPagination):
    """
    商品列表自定义分页
    """
    page_size = 12                      # 每页显示条数
    page_size_query_param = 'page_size' # 修改"每页显示条数"
    page_query_param = 'page'           # 页码参数名字
    max_page_size = 10000               # 最多显示页码数

class GoodsListViewSet(mixins.ListModelMixin,viewsets.GenericViewSet):
    """
    商品列表页，分页，过滤器，搜索，排序
    """
    queryset = Goods.objects.all().order_by('goods__category_id')   # queryset不可以更改
    serializer_class = GoodsSerializer                              # 引用序列化相应的对象
    pagination_class = GooodsPagination                             # 引用商品列表自定义分页
    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') # 排序字段

class CategoryViewSet(mixins.ListModelMixin,mixins.RetrieveModelMixin,viewsets.GenericViewSet):
    """
    list:商品分类列表数据
    retrieve:获取商品分类详情
    """
    queryset = GoodsCategory.objects.filter(category_type=1)  # 取出所有对象
    serializer_class = CategorySerializer                     # 序列化相应的对象

import django_filters
from goods.models import Goods
from django.db.models import Q #增加Q方法用来构造复杂or查询

class GoodsFilter(django_filters.rest_framework.FilterSet):
    """
    商品的过滤类
    """
    pricemin = django_filters.NumberFilter(field_name="shop_price",help_text ='最低价格',lookup_expr='gte') # 新版已改成field_name，使用name会报错
    pricemax = django_filters.NumberFilter(field_name="shop_price",help_text ='最高价格',lookup_expr='lte')
    # name = django_filters.CharFilter(field_name='name',lookup_expr='icontains') # 模糊匹配
    top_category = django_filters.NumberFilter(method='top_catagory_filter')

    def top_catagory_filter(self,queryset,name,value):
        queryset = queryset.filter(Q(category_id = value)|Q(category__parent_category_id = value)|Q(category__parent_category__parent_category_id=value))
        return queryset

    class Meta:
        model = Goods
        fields = ['pricemin','pricemax']

from rest_framework import serializers
from goods.models import Goods,GoodsCategory


class CategorySerializer3(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class CategorySerializer2(serializers.ModelSerializer):
    sub_cat = CategorySerializer3(many=True)
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class CategorySerializer(serializers.ModelSerializer):
    """
    商品一级类别序列化
    """
    sub_cat = CategorySerializer2(many=True)
    class Meta:
        model = GoodsCategory
        fields = "__all__"

class GoodsSerializer(serializers.ModelSerializer):
    category = CategorySerializer()    # category为外键字段，实例化操作
    class Meta:
        model = Goods
        # fields = ('id', 'category', 'goods_sn', 'name', 'goods_front_image', 'add_time')
        fields = "__all__"

from django.contrib.auth.backends import ModelBackend
from django.db.models import Q

from django.contrib.auth import get_user_model  # settings中设置了AUTH_USER_MODEL
User = get_user_model()
# from users.models import UserProfile

class CustomBackend(ModelBackend):
    """
    自定义用户验证
    """
    def authenticate(self, username=None, password=None, **kwargs):
        try:
            user = User.objects.get(Q(username=username)|Q(mobile=username))
            if user.check_password(password):
                return user
        except Exception as e:
            return None

import requests
import json

class Yunpian(object):

    def __init__(self,apikey):
        self.apikey = apikey
        self.single_send_url = "https://sms.yunpian.com/v2/sms/single_send.json"

    def send_msg(self,mobile,code):
        parmas = {
            "apikey":self.apikey,
            "mobile" : mobile,
            "text" : "【搞笑的】您的验证码是{code}。如非本人操作，请忽略本短信".format(code=code)
        }

        response = requests.post(self.single_send_url,data=parmas)
        re_dict = json.loads(response.text)
        return re_dict

if __name__ == "__main__":
    yun_pian = Yunpian("")
    yun_pian.send_msg("","2019")

import re
from Shop.settings import REGEX_MOBILE
from datetime import datetime,timedelta
from rest_framework import serializers
from users.models import VerifyCode
from django.contrib.auth import get_user_model  # settings中设置了AUTH_USER_MODEL
User = get_user_model()
# from users.models import UserProfile

class MesSerializer(serializers.Serializer):
    mobile = serializers.CharField(max_length=11)

    # 函数名必须：validate + 验证字段名
    def  validate_mobile(self,mobile):
        """
        验证手机号码
        :param mobile:
        :return:
        """
        # 手机是否注册
        if User.objects.filter(mobile=mobile).count():
            raise serializers.ValidationError('用户已经存在')

        # 验证手机号码是否合法
        if not re.match(REGEX_MOBILE,mobile):
            raise serializers.ValidationError("手机号码非法")

        # 验证码发送频率
        one_mintes_ago = datetime.now()-timedelta(hours=0,minutes=1,seconds=0)
        if VerifyCode.objects.filter(add_time__gt=one_mintes_ago,mobile=mobile).count():
            raise serializers.ValidationError("距离上一次发送未超过60s")

        return mobile

from django.contrib.auth.backends import ModelBackend
from django.db.models import Q

from django.contrib.auth import get_user_model  # settings中设置了AUTH_USER_MODEL
User = get_user_model()
# from users.models import UserProfile
from rest_framework.mixins import CreateModelMixin
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from random import choice

from users.serializers import MesSerializer
from Shop.settings import APIKEY
from users.models import VerifyCode

from utils.yunpian import Yunpian
class MsgCodeViewset(CreateModelMixin, viewsets.GenericViewSet):
    """
    发送短信验证码
    """
    serializer_class = MesSerializer

    def generate_code(self):
        """
        生成四位数的验证码
        :return:
        """
        seeds = "1234567890"    # 种子
        random_str = []
        for i in range(4):
            random_str.append(choice(seeds))

        return "".join(random_str)


    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        mobile = serializer.validated_data["mobile"] # 是一个字典

        yun_pian = Yunpian(APIKEY)  # settings中设置了APIKEY

        code = self.generate_code()

        msg_status = yun_pian.send_msg(mobile=mobile,code=code)

        if msg_status["code"] != 0: # 不为0返回400错误提示,为0时返回201正确提示
            return Response({
                "mobile":msg_status["msg"]
            },status=status.HTTP_400_BAD_REQUEST)
        else:
            code_record = VerifyCode(mobile=mobile,code=code) # 为0时正确，并把mobile跟code录入数据库
            code_record.save()
            return Response({
                "mobile":mobile
            },status=status.HTTP_201_CREATED)

from rest_framework.validators import UniqueValidator

class 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.自带验证，最大长度最小长度为4
        3.验证码过期
        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 attrs

    class 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 = UserRegSerializer
    queryset = 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 receiver

from 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_save
    if created:
        password = instance.password
        #instance相当于user
        instance.set_password(password)
        instance.save()

from django.apps import AppConfig


class UsersConfig(AppConfig):
    name = 'users'
    verbose_name = '用户管理'

    def ready(self):
        import users.signals

class UserViewset(CreateModelMixin, viewsets.GenericViewSet):
    """
    用户
    """
    serializer_class = UserRegSerializer
    queryset = 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.data
        payload = jwt_payload_handler(user)
        re_dict["token"] = jwt_encode_handler(payload)
        re_dict["name"] = user.name if user.name else user.username

        headers = 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 = GoodsImage
        fields = ("image",)

class GoodsSerializer(serializers.ModelSerializer):
    # 覆盖外键字段
    category = CategorySerializer()    # category为外键字段，实例化操作
    images = GoodsImageSerializer(many=True) # 变量名为外键的related_name
    class 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 = Goods
        fields = ['pricemin','pricemax','is_hot']

from rest_framework import serializers
from user_operation.models import UserFav
from rest_framework.validators import UniqueTogetherValidator

class 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 mixins

from user_operation.models import UserFav
from user_operation.serializers import UserFavSerializer

class UserFavViewset(viewsets.GenericViewSet,mixins.ListModelMixin,mixins.CreateModelMixin,mixins.DestroyModelMixin):
    """
    用户收藏功能列表
    """
    queryset = UserFav.objects.all()
    serializer_class = UserFavSerializer

from rest_framework import permissions

class 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修改为user
        return obj.user == request.user

from rest_framework import viewsets
from rest_framework import mixins

from 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

class 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 mixins

from 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 SessionAuthentication


class 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 = User
        fields = ("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,UserDetailSerializer

class UserViewset(CreateModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """
    用户
    """
    serializer_class = UserRegSerializer
    queryset = 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 UserDetailSerializer
        elif self.action == "create":
            return UserRegSerializer
        return 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.data
        payload = jwt_payload_handler(user)
        re_dict["token"] = jwt_encode_handler(payload)
        re_dict["name"] = user.name if user.name else user.username

        headers = 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.user

    def 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 = UserFav
        fields = ("goods","id")

from rest_framework import viewsets
from rest_framework import mixins

from 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 SessionAuthentication


class 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"

    # 动态选择serializer
    def get_serializer_class(self):
        if self.action == "list":
            return UserFavDetailSerializer
        elif self.action == "create":
            return UserFavSerializer
        return 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 = UserLeavingMessage
        fields = ("user","message_type","subject","message","file","id","add_time")

from rest_framework import viewsets
from rest_framework import mixins

from 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 SessionAuthentication

class 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 = UserAddress
        fields = ("id","user", "province", "city", "district", "address", "signer_name","signer_mobile", "add_time")

from rest_framework import viewsets
from rest_framework import mixins

from 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 SessionAuthentication

class 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 serializers

from goods.models import Goods
from trade.models import ShoppingCart

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"].user
        nums = validated_data["nums"]
        goods = validated_data["goods"]

        existed = ShoppingCart.objects.filter(user=user, goods=goods)
        # 如果购物车中有记录，现有数量+原来数量
        # 如果购物车车没有记录，就创建
        if existed:
            existed = existed[0]
            existed.nums += nums
            existed.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 JSONWebTokenAuthentication

from trade.serializers import ShopCartSerializer
from trade.models import ShoppingCart
from utils.permissions import IsOwnerOrReadOnly

class 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 GoodsSerializer

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

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

from rest_framework import serializers

from goods.models import Goods
from trade.models import OrderInfo,OrderGoods
from goods.serializers import GoodsSerializer

class OrderGoodsSerializer(serializers.ModelSerializer):
    # 订单详情中的商品信息
    goods = GoodsSerializer(many=False)
    class Meta:
        model = OrderGoods
        fields = "__all__"

class OrderDetailSerializer(serializers.ModelSerializer):
    # 订单详情
    goods = OrderGoodsSerializer(many=True)
    class Meta:
        model = OrderInfo
        fields = "__all__"

class OrderSerializer(serializers.ModelSerializer):
    # 获取当前登录的用户,界面不显示user,相当于read_only
    user = 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)

    def generate_order_sn(self):
        # 生成订单号，当前时间 + userid + 两位随机数
        import time
        from random import Random
        random_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_sn

    def validate(self, attrs):
        # 实例化上面方法，validate中添加order_sn，在view中perform_create方法里save
        attrs["order_sn"]=self.generate_order_sn()
        return attrs

    class Meta:
        model = OrderInfo
        fields = "__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 mixins

from trade.serializers import OrderSerializer,OrderDetailSerializer
from trade.models import OrderInfo,OrderGoods
from utils.permissions import IsOwnerOrReadOnly

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 OrderDetailSerializer
        return 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.goods
            order_goods.goods_num = shop_cart.nums
            order_goods.order = order
            order_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, encodebytes

import json


class AliPay(object):
    """
    支付宝支付接口
    """
    def __init__(self, appid, app_notify_url, app_private_key_path,
                 alipay_public_key_path, return_url, debug=False):
        self.appid = appid
        self.app_notify_url = app_notify_url
        # 应用私钥
        self.app_private_key_path = app_private_key_path
        self.app_private_key = None
        self.return_url = return_url
        with open(self.app_private_key_path) as fp:
            self.app_private_key = RSA.importKey(fp.read())

        # 阿里公钥
        self.alipay_public_key_path = alipay_public_key_path
        with 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_url
            data["return_url"] = self.return_url

        return data

    def 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_string

    def 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 sign

    def _verify(self, raw_content, signature):
        # 开始计算签名
        key = self.alipay_public_key
        signer = PKCS1_v1_5.new(key)
        digest = SHA256.new()
        digest.update(raw_content.encode("utf8"))
        if signer.verify(digest, decodebytes(signature.encode("utf8"))):
            return True
        return False

    def 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是异步的url
        app_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。如果不是用正式环境的url
        debug=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同步的url
        return_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, encodebytes

class AliPay(object):
    """
    支付宝支付接口
    """
    def __init__(self, appid, app_notify_url, app_private_key_path,
                 alipay_public_key_path, return_url, debug=False):
        self.appid = appid
        self.app_notify_url = app_notify_url
        # 应用私钥
        self.app_private_key_path = app_private_key_path
        self.app_private_key = None
        self.return_url = return_url
        with open(self.app_private_key_path) as fp:
            self.app_private_key = RSA.importKey(fp.read())

        # 阿里公钥
        self.alipay_public_key_path = alipay_public_key_path
        with 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_url
            data["return_url"] = self.return_url

        return data

    def 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_string

    def 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 sign

    def _verify(self, raw_content, signature):
        # 开始计算签名
        key = self.alipay_public_key
        signer = PKCS1_v1_5.new(key)
        digest = SHA256.new()
        digest.update(raw_content.encode("utf8"))
        if signer.verify(digest, decodebytes(signature.encode("utf8"))):
            return True
        return False

    def 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是异步的url
        app_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。如果不是用正式环境的url
        debug=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同步的url
        return_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是异步的url
            app_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。如果不是用正式环境的url
            debug=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_status
                existed_order.trade_no = trade_no
                existed_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是异步的url
            app_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。如果不是用正式环境的url
            debug=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_status
                existed_order.trade_no = trade_no
                existed_order.pay_time = datetime.now()
                existed_order.save()
            # 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息
            return Response('success')

from rest_framework import serializers

from 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_path

class ShopCartDetailSerializer(serializers.ModelSerializer):
    """
    购物车详情信息
    """
    # 一个购物车对应一个商品
    goods = GoodsSerializer(many=False)
    class Meta:
        model = ShoppingCart
        fields = "__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"].user
        nums = validated_data["nums"]
        goods = validated_data["goods"]

        existed = ShoppingCart.objects.filter(user=user, goods=goods)
        # 如果购物车中有记录，数量+1
        # 如果购物车车没有记录，就创建
        if existed:
            existed = existed[0]
            existed.nums += nums
            existed.save()
        else:
            existed = ShoppingCart.objects.create(**validated_data)
        return existed


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

class OrderGoodsSerializer(serializers.ModelSerializer):
    # 订单详情中的商品信息
    goods = GoodsSerializer(many=False)
    class Meta:
        model = OrderGoods
        fields = "__all__"

class OrderDetailSerializer(serializers.ModelSerializer):
    # 订单详情
    goods = OrderGoodsSerializer(many=True)

    # 支付订单的url
    # 参考网址：https://www.django-rest-framework.org/api-guide/fields/#serializermethodfield
    alipay_url = serializers.SerializerMethodField(read_only=True)

    def get_alipay_url(self, obj):
        # 测试用例
        alipay = AliPay(
            # 沙箱里面的appid值
            appid="2016092900626681",
            # notify_url是异步的url
            app_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。如果不是用正式环境的url
            debug=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_url

    class Meta:
        model = OrderInfo
        fields = "__all__"

class OrderSerializer(serializers.ModelSerializer):
    # 获取当前登录的用户,界面不显示user,相当于read_only
    user = 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/#serializermethodfield
    alipay_url = serializers.SerializerMethodField(read_only=True)

    def get_alipay_url(self, obj):
        # 测试用例
        alipay = AliPay(
            # 沙箱里面的appid值
            appid="2016092900626681",
            # notify_url是异步的url
            app_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。如果不是用正式环境的url
            debug=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_url

    def generate_order_sn(self):
        # 生成订单号，当前时间 + userid + 两位随机数
        import time
        from random import Random
        random_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_sn

    def validate(self, attrs):
        # 实例化上面方法，validate中添加order_sn，在view中perform_create方法里save
        attrs["order_sn"]=self.generate_order_sn()
        return attrs

    class Meta:
        model = OrderInfo
        fields = "__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 mixins

from trade.serializers import ShopCartSerializer,ShopCartDetailSerializer,OrderSerializer,OrderDetailSerializer
from trade.models import ShoppingCart,OrderInfo,OrderGoods
from utils.permissions import IsOwnerOrReadOnly

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 ShopCartDetailSerializer
        else:
            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 OrderDetailSerializer
        return 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.goods
            order_goods.goods_num = shop_cart.nums
            order_goods.order = order
            order_goods.save()
            # 清空购物车
            shop_cart.delete()
        return order

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
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是异步的url
            app_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。如果不是用正式环境的url
            debug=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_status
                existed_order.trade_no = trade_no
                existed_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 response
        else:
            response = redirect("index")
            return response

    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是异步的url
            app_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。如果不是用正式环境的url
            debug=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_status
                existed_order.trade_no = trade_no
                existed_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') # 排序字段

    # 商品数+1
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.click_num += 1
        instance.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'

    #动态选择serializer
    def get_serializer_class(self):
        if self.action == "list":
            return UserFavDetailSerializer
        elif self.action == "create":
            return UserFavSerializer
        return UserFavSerializer

    def get_queryset(self):
        #只能查看当前登录用户的收藏，不会获取所有用户的收藏
        return UserFav.objects.filter(user=self.request.user)

    # 用户收藏的商品数量+1
    def perform_create(self, serializer):
        instance = serializer.save()
        # 这里instance相当于UserFav model，通过它找到goods
        goods = instance.goods
        goods.fav_num += 1
        goods.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 ShopCartDetailSerializer
        else:
            return ShopCartSerializer

    # 返回当前用户购物车列表页
    def get_queryset(self):
        return ShoppingCart.objects.filter(user=self.request.user)

    # 库存数-1,购物车数+1
    def perform_create(self, serializer):
        shop_cart = serializer.save()
        goods = shop_cart.goods
        goods.goods_num -= shop_cart.nums
        goods.save()

    # 库存数+1，删除购物车
    def perform_destroy(self, instance):
        goods = instance.goods
        goods.goods_num += instance.nums
        goods.save()
        instance.delete()

    # 更新库存数,修改可能是增加也可能是减少
    def perform_update(self, serializer):
        # 首先获取修改之前的库存数量
        existed_record = ShoppingCart.objects.get(serializer.instance.id)
        # 先保存之前的数据existed_nums(存在购买记录)
        existed_nums = existed_record.nums
        saved_record = serializer.save()
        # 数量变化
        nums = saved_record.nums - existed_nums
        goods = saved_record.goods
        goods.goods_num -= nums
        goods.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 OrderDetailSerializer
        return 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.goods
            order_goods.goods_num = shop_cart.nums
            order_goods.order = order
            order_goods.save()
            # 清空购物车
            shop_cart.delete()
        return order

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
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是异步的url
            app_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。如果不是用正式环境的url
            debug=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_status
                existed_order.trade_no = trade_no
                existed_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 response
        else:
            response = redirect("index")
            return response

    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是异步的url
            app_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。如果不是用正式环境的url
            debug=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.goods
                    goods.sold_num += order_good.goods_num
                    goods.save()

                # 更新订单状态
                existed_order.pay_status = trade_status
                existed_order.trade_no = trade_no
                existed_order.pay_time = datetime.now()
                existed_order.save()
            # 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息
            return Response('success')