from rest_framework import serializers

from .models import Area


class AreaSerializer(serializers.ModelSerializer):
    """
    行政区划信息序列化器
    """
    class Meta:
        model = Area
        fields = (‘id‘, ‘name‘)


class SubAreaSerializer(serializers.ModelSerializer):
    """
    子行政区划信息序列化器
    """
    subs = AreaSerializer(many=True, read_only=True)

    class Meta:
        model = Area
        fields = (‘id‘, ‘name‘, ‘subs‘)

#!/usr/bin/env python

"""
功能：手动生成所有SKU的静态detail html文件
使用方法:
    ./regenerate_detail_html.py
"""
import sys
sys.path.insert(0, ‘../‘)
sys.path.insert(0, ‘../meiduo_mall/apps‘)

import os
if not os.getenv(‘DJANGO_SETTINGS_MODULE‘):
    os.environ[‘DJANGO_SETTINGS_MODULE‘] = ‘meiduo_mall.settings.dev‘

import django
django.setup()

from django.template import loader
from django.conf import settings

from goods.utils import get_categories
from goods.models import SKU


def generate_static_sku_detail_html(sku_id):
    """
    生成静态商品详情页面
    :param sku_id: 商品sku id
    """
    # 商品分类菜单
    categories = get_categories()

    # 获取当前sku的信息
    sku = SKU.objects.get(id=sku_id)
    sku.images = sku.skuimage_set.all()

    # 面包屑导航信息中的频道
    goods = sku.goods
    goods.channel = goods.category1.goodschannel_set.all()[0]

    # 构建当前商品的规格键
    sku_specs = sku.skuspecification_set.order_by(‘spec_id‘)
    sku_key = []
    for spec in sku_specs:
        sku_key.append(spec.option.id)
    print("当前商品的规格键[1,4,7]",sku_key)
    # 获取当前商品的所有SKU
    skus = goods.sku_set.all()
    print("获取当前商品的所在的SPU下的所有SKU对象",skus)

    # 构建不同规格参数（选项）的sku字典
    # spec_sku_map = {
    #     (规格1参数id, 规格2参数id, 规格3参数id, ...): sku_id,
    #     (规格1参数id, 规格2参数id, 规格3参数id, ...): sku_id,
    #     ...
    # }

    spec_sku_map = {}
    for s in skus:
        # 获取sku的规格参数
        s_specs = s.skuspecification_set.order_by(‘spec_id‘)
        # 用于形成规格参数-sku字典的键
        key = []
        for spec in s_specs:
            key.append(spec.option.id)
        # 向规格参数-sku字典添加记录
        # print("构造出的不同规格的参数",key)
        spec_sku_map[tuple(key)] = s.id
    print("{(1, 4, 7): 1, (1, 3, 7): 2}构造出的不同规格的参数",spec_sku_map)

    # 获取当前商品的规格信息
    specs = goods.goodsspecification_set.order_by(‘id‘)
    print("当前商品所有的规格选项，屏幕，颜色，，，",specs)
    # print("sku_key",sku_key)
    # 若当前sku的规格信息不完整，则不再继续
    if len(sku_key) < len(specs):
        return
    for index, spec in enumerate(specs):
        # if index == 0:
        #     print("index", index)
        #     print("GoodsSpecification的规格信息对象", spec)
        # 复制当前sku的规格键
        key = sku_key[:]
        print("当前的规格选项",spec.name)
        # 该规格的选项
        options = spec.specificationoption_set.all()
        print("options规格信息的选项", options)
        for option in options:
            # 在规格参数sku字典中查找符合当前规格的sku
            print("001",key)
            print("固定不变的数据库中只有这两种商品spec_sku_map",spec_sku_map)
            print("option.id", option.id)
            key[index] = option.id
            print("002",key)
            option.sku_id = spec_sku_map.get(tuple(key))
            print(option.sku_id)


        spec.options = options

    # 渲染模板，生成静态html文件
    context = {
        ‘categories‘: categories,
        ‘goods‘: goods,
        ‘specs‘: specs,
        ‘sku‘: sku
    }

    template = loader.get_template(‘detail.html‘)
    html_text = template.render(context)
    file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR, ‘goods/‘+str(sku_id)+‘.html‘)
    with open(file_path, ‘w‘) as f:
        f.write(html_text)

if __name__ == ‘__main__‘:
    sku = SKU.objects.get(id=1)
    generate_static_sku_detail_html(sku.id)

当前商品的规格键[1,4,7] [1, 4, 7]
获取当前商品的所在的SPU下的所有SKU对象 <QuerySet [<SKU: 1: Apple MacBook Pro 13.3英寸笔记本 银色>, <SKU: 2: Apple MacBook Pro 13.3英寸笔记本 深灰色>]>
{(1, 4, 7): 1, (1, 3, 7): 2}构造出的不同规格的参数 {(1, 4, 7): 1, (1, 3, 7): 2}
当前商品所有的规格选项，屏幕，颜色，，， <QuerySet [<GoodsSpecification: Apple MacBook Pro 笔记本: 屏幕尺寸>, <GoodsSpecification: Apple MacBook Pro 笔记本: 颜色>, <GoodsSpecification: Apple MacBook Pro 笔记本: 版本>]>
当前的规格选项 屏幕尺寸
options规格信息的选项 <QuerySet [<SpecificationOption: Apple MacBook Pro 笔记本: 屏幕尺寸 - 13.3英寸>, <SpecificationOption: Apple MacBook Pro 笔记本: 屏幕尺寸 - 15.4英寸>]>
001 [1, 4, 7]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 1
002 [1, 4, 7]
1
001 [1, 4, 7]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 2
002 [2, 4, 7]
None
当前的规格选项 颜色
options规格信息的选项 <QuerySet [<SpecificationOption: Apple MacBook Pro 笔记本: 颜色 - 深灰色>, <SpecificationOption: Apple MacBook Pro 笔记本: 颜色 - 银色>]>
001 [1, 4, 7]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 3
002 [1, 3, 7]
2
001 [1, 3, 7]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 4
002 [1, 4, 7]
1
当前的规格选项 版本
options规格信息的选项 <QuerySet [<SpecificationOption: Apple MacBook Pro 笔记本: 版本 - core i5/8G内存/256G存储>, <SpecificationOption: Apple MacBook Pro 笔记本: 版本 - core i5/8G内存/128G存储>, <SpecificationOption: Apple MacBook Pro 笔记本: 版本 - core i5/8G内存/512G存储>]>
001 [1, 4, 7]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 5
002 [1, 4, 5]
None
001 [1, 4, 5]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 6
002 [1, 4, 6]
None
001 [1, 4, 6]
固定不变的数据库中只有这两种商品spec_sku_map {(1, 4, 7): 1, (1, 3, 7): 2}
option.id 7
002 [1, 4, 7]
1

 specs = [
    {
        ‘name‘: ‘屏幕尺寸‘,
        ‘options‘: [
            {‘value‘: ‘13.3寸‘, ‘sku_id‘: xxx},
            {‘value‘: ‘15.4寸‘, ‘sku_id‘: xxx},
        ]
    },
    {
        ‘name‘: ‘颜色‘,
        ‘options‘: [
            {‘value‘: ‘银色‘, ‘sku_id‘: xxx},
            {‘value‘: ‘黑色‘, ‘sku_id‘: xxx}
        ]
    },
    ...
 ]

 specs = [
    {
        ‘name‘: ‘屏幕尺寸‘,
        ‘options‘: [
            {‘value‘: ‘13.3寸‘, ‘sku_id‘: Iphone7的sku_id},
            {‘value‘: ‘15.4寸‘, ‘sku_id‘: Iphone6的sku_id},
            {‘value‘: ‘15.4寸‘, ‘sku_id‘: Iphone7的sku_id2},
        ]
    },
    {
        ‘name‘: ‘颜色‘,
        ‘options‘: [
            {‘value‘: ‘银色‘, ‘sku_id‘: Iphone7的sku_id},
            {‘value‘: ‘银色‘, ‘sku_id‘: Iphone6的sku_id},
            {‘value‘: ‘金色‘, ‘sku_id‘: Iphone7的sku_id2},
        ]
    },
    ...
 ]

class SKUSpecificationAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        obj.save()
        from celery_tasks.html.tasks import generate_static_sku_detail_html
        generate_static_sku_detail_html.delay(obj.sku.id)

    def delete_model(self, request, obj):
        sku_id = obj.sku.id
        obj.delete()
        from celery_tasks.html.tasks import generate_static_sku_detail_html
        generate_static_sku_detail_html.delay(sku_id)

class CartMixin():
    def str2dict(self, redis_data):  # redis_data从redis中读取的数据
        """ 转化为python字典"""
        redis_dict = pickle.loads(base64.b64decode(redis_data))
        return redis_dict

    def dict2str(self, redis_dict):
        """ python中dict转为可以存入redis中的数据"""
        # 将合并后的字典再次存入到redis中
        redis_bytes = pickle.dumps(redis_dict)
        redis_str = base64.b64encode(redis_bytes)
        return redis_str

    def write_cart(self, request: Request, response: Response, cart_dict: dict):
        """ 写购物车数据"""
        cart_str = self.dict2str(cart_dict)
        if request.user.is_authenticated:
            key = "cart2_%s" % request.user.id
            get_redis_connection("cart").set(key, cart_str)
        else:
            response.set_cookie("cart", cart_str)

    def read_from_redis(self, user_id):
        """ 返回一个字典"""
        key = "cart2_%s" % user_id
        redis_data = get_redis_connection("cart").get(key)

        if redis_data is None:
            return {}
        return self.str2dict(redis_data)

    def read_from_cookie(self, request: Request):
        value = request.COOKIES.get("cart")
        if value is None:
            return {}
        return self.str2dict(value)

    def read(self, request: Request) -> dict:
        if request.user.is_authenticated:
            cart_dict = self.read_from_redis(request.user.id)
        else:
            cart_dict = self.read_from_cookie(request)
        return cart_dict


class CartView(CartMixin, APIView):
    # pagination_class = StandardResultsSerPagination

    def post(self, request):
        serializer = CartSerializer(data=request.data)  # 检查前端发送过来数据是否正确
        serializer.is_valid(raise_exception=True)  # 数据检验通过
        sku_id = serializer.validated_data[‘sku_id‘]
        count = serializer.validated_data[‘count‘]
        selected = serializer.validated_data["selected"]

        cart_dict = self.read(request)
        if sku_id in cart_dict:
            #
            new_count = cart_dict[sku_id][0] + count
            cart_dict[sku_id] = [new_count, selected]
        else:
            cart_dict[sku_id] = [count, selected]

        resp = Response(serializer.data, status=status.HTTP_201_CREATED)
        self.write_cart(request, resp, cart_dict)
        return resp

    def get(self, request):
        cart_dict = self.read(request)
        skus = SKU.objects.filter(id__in=cart_dict.keys())

        for sku in skus:
            sku.count = cart_dict[sku.id][0]
            sku.selected = cart_dict[sku.id][1]

        serializer = CartSKUSerializer(skus, many=True)

        return Response(serializer.data)

    def put(self, request):
        # 检查前端发送的数据是否正确
        serializer = CartSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        sku_id = serializer.validated_data.get(‘sku_id‘)
        count = serializer.validated_data.get(‘count‘)
        selected = serializer.validated_data.get(‘selected‘)

        cart_dict = self.read(request)

        cart_dict[sku_id] = [count, selected]
        resp = Response(serializer.data, status=status.HTTP_201_CREATED)
        self.write_cart(request, resp, cart_dict)
        return resp

    def delete(self, request):
        # 检查参数sku_id
        serializer = CartDeleteSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        sku_id = serializer.validated_data[‘sku_id‘]

        cart_dict = self.read(request)

        if sku_id in cart_dict:
            del cart_dict[sku_id]
        resp = Response(serializer.data, status=status.HTTP_204_NO_CONTENT)
        self.write_cart(request, resp, cart_dict)

        return resp

def merge_cart_cookie_to_redis(request, response, user):
    """ 合并购物车"""
    cookies_cart = request.COOKIES.get(‘cart‘)
    if cookies_cart is not None:
        cookies_dict = pickle.loads(base64.b64decode(cookies_cart))  # 取出cookies中的数据
        print("cookies_dict000", cookies_dict)
        redis_conn = get_redis_connection("cart")
        redis_cart = redis_conn.get("cart2_%s" % user.id)  #
        redis_dict = {}
        if redis_cart:
            redis_dict = pickle.loads(base64.b64decode(redis_cart))  # 取出的是redis中的数据
        print("redis_dict001", redis_dict)

        # 过滤购物车中没有被选中的商品
        new_cookies_dict = deepcopy(cookies_dict)
        for sku_id, value in cookies_dict.items():
            if not value[1]:
                new_cookies_dict.pop(sku_id)

        print("redis_dict002", new_cookies_dict)

        # 合并cookies中的值
        redis_dict.update(new_cookies_dict)

        print("redis_dict003", redis_dict)

        redis_str = base64.b64encode(pickle.dumps(redis_dict))
        key = "cart2_%s" % user.id
        get_redis_connection("cart").set(key, redis_str)

        # 往redis中写入数据
        # if cart:
        #     pl = redis_conn.pipeline()
        #     pl.hmset("cart_%s" % user.id, cart)
        #     pl.sadd("cart_selected_%s" % user.id, *redis_cart_selected)
        #     pl.execute()

        # 删除cookie中的数据
        response.delete_cookie("cart")
        return response
    return response

from django.db import models
from meiduo_mall.utils.models import BaseModel
from users.models import User, Address
from goods.models import SKU


# Create your models here.


class OrderInfo(BaseModel):
    """
    订单信息
    """
    PAY_METHODS_ENUM = {
        "CASH": 1,
        "ALIPAY": 2
    }

    PAY_METHOD_CHOICES = (
        (1, "货到付款"),
        (2, "支付宝"),
    )

    ORDER_STATUS_ENUM = {
        "UNPAID": 1,
        "UNSEND": 2,
        "UNRECEIVED": 3,
        "UNCOMMENT": 4,
        "FINISHED": 5
    }

    ORDER_STATUS_CHOICES = (
        (1, "待支付"),
        (2, "待发货"),
        (3, "待收货"),
        (4, "待评价"),
        (5, "已完成"),
        (6, "已取消"),
    )

    order_id = models.CharField(max_length=64, primary_key=True, verbose_name="订单号")
    user = models.ForeignKey(User, on_delete=models.PROTECT, verbose_name="下单用户")
    address = models.ForeignKey(Address, on_delete=models.PROTECT, verbose_name="收获地址")
    total_count = models.IntegerField(default=1, verbose_name="商品总数")
    total_amount = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="商品总金额")
    freight = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="运费")
    pay_method = models.SmallIntegerField(choices=PAY_METHOD_CHOICES, default=1, verbose_name="支付方式")
    status = models.SmallIntegerField(choices=ORDER_STATUS_CHOICES, default=1, verbose_name="订单状态")

    class Meta:
        db_table = "tb_order_info"
        verbose_name = ‘订单基本信息‘
        verbose_name_plural = verbose_name


class OrderGoods(BaseModel):
    """
    订单商品
    """
    SCORE_CHOICES = (
        (0, ‘0分‘),
        (1, ‘20分‘),
        (2, ‘40分‘),
        (3, ‘60分‘),
        (4, ‘80分‘),
        (5, ‘100分‘),
    )
    order = models.ForeignKey(OrderInfo, related_name=‘skus‘, on_delete=models.CASCADE, verbose_name="订单")
    sku = models.ForeignKey(SKU, on_delete=models.PROTECT, verbose_name="订单商品")
    count = models.IntegerField(default=1, verbose_name="数量")
    price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="单价")
    comment = models.TextField(default="", verbose_name="评价信息")
    score = models.SmallIntegerField(choices=SCORE_CHOICES, default=5, verbose_name=‘满意度评分‘)
    is_anonymous = models.BooleanField(default=False, verbose_name=‘是否匿名评价‘)
    is_commented = models.BooleanField(default=False, verbose_name=‘是否评价了‘)

    class Meta:
        db_table = "tb_order_goods"
        verbose_name = ‘订单商品‘
        verbose_name_plural = verbose_name

- 用户必须在登录的状态下才可以进入到购物车商品结算的页面
- 查询到当前订单的用户；
- 在redis数据库中将当前用户的购物车中所有商品查询出来
- 过滤筛选出用户选中的商品信息的id
- 查询出当前订单的运费的
- 将相关信息(例如运费和查询出来的商品的skus对象)传递给序列化器，序列化器将数据从数据库中序列化后返回给前端

{
    "freight":"10.00",
    "skus":[
        {
            "id":10,
            "name":"华为 HUAWEI P10 Plus 6GB+128GB 钻雕金 移动联通电信4G手机 双卡双待",
             "default_image_url":"http://image.meiduo.site:8888/group1/M00/00/02/CtM3BVrRchWAMc8rAARfIK95am88158618",
            "price":"3788.00",
            "count":1
        },
        {
            "id":16,
            "name":"华为 HUAWEI P10 Plus 6GB+128GB 曜石黑 移动联通电信4G手机 双卡双待",
            "default_image_url":"http://image.meiduo.site:8888/group1/M00/00/02/CtM3BVrRdPeAXNDMAAYJrpessGQ9777651",
            "price":"3788.00",
            "count":1
        }
    ]
}

class SaveOrderSerializer(serializers.ModelSerializer):
    """ 用户支付订单的创建序列化器"""

    class Meta:
        model = OrderInfo
        fields = ("order_id", "address", "pay_method")
        read_only_fields = ("order_id",)
        extra_kwargs = {
            "address": {
                "write_only": True,
                "required": True
            },
            "pay_method": {
                "write_only": True,
                "required": True
            }
        }

    def create(self, validated_data):
        """ 保存订单序列化器"""
        # 获取当前下单用户
        user = self.context[‘request‘].user
        address = validated_data.get("address")
        pay_method = validated_data.get("pay_method")
        # 组织订单信息20170903153611+user.id
        order_id = timezone.now().strftime("%Y%m%d%H%M%S") + ("%09d" % user.id)

        # 开启事务
        with transaction.atomic():
            # 创建保存点，记录当前数据状态
            save_id = transaction.savepoint()
            try:
                # 保存订单基本信息数据 OrderInfo
                order = OrderInfo.objects.create(**{
                    "order_id": order_id,
                    ‘user‘: user,
                    ‘address‘: address,
                    ‘total_count‘: 0,
                    "total_amount": Decimal(0),
                    "freight": Decimal(10),
                    "pay_method": pay_method,
                    #  如果用户选择现金支付，订单状态为待发货；反之为待支付
                    "status": OrderInfo.ORDER_STATUS_ENUM[‘UNSEND‘] if validated_data[‘pay_method‘] ==
                                                                       OrderInfo.PAY_METHODS_ENUM[‘CASH‘]
                    else OrderInfo.ORDER_STATUS_ENUM[‘UNPAID‘]
                })

                redis_conn = get_redis_connection("cart")
                # 从redis中获取购物车结算商品数据
                selected_sku_id_list = []
                redis_cart = redis_conn.get("cart2_%s" % user.id)  #
                redis_dict = pickle.loads(base64.b64decode(redis_cart))  # 取出的是redis中的数据
                # 过滤购物车中被选中的商品的id
                for sku_id, value in redis_dict.items():
                    if value[1]:
                        selected_sku_id_list.append(sku_id)

                # 冗余数据先设置默认值
                order.total_amount = Decimal(0)
                order.total_count = 0

                # 查询商品信息
                # skus = SKU.objects.filter(id__in=cart_dict.keys())  # 得到选中的商品objs
                # 遍历结算商品：
                for sku_id in selected_sku_id_list:
                    while True:
                        sku = SKU.objects.get(id=sku_id)
                        # 要购买的商品的数量
                        count = redis_dict[sku.id][0]

                        # 判断库存量和销售量
                        origin_stock = sku.stock
                        origin_sales = sku.sales
                        # 判断商品库存是否充足
                        if count > origin_stock:
                            transaction.savepoint_rollback(save_id)
                            raise serializers.ValidationError({"库存不足"})

                        # 更新库存和销量信息
                        new_stock = origin_stock - count
                        new_sales = origin_sales + count
                        # sku.stock = new_stock
                        # sku.sales = new_sales

                        # 返回受影响的行数
                        ret = SKU.objects.filter(id=sku.id, stock=origin_stock).update(stock=new_stock, sales=new_sales)
                        if ret == 0:
                            continue

                        # 计算order——info中的两个冗余字段结果并赋值
                        order.total_count += count
                        order.total_amount += (sku.price * count)

                        OrderGoods.objects.create(**{
                            "order": order,
                            "sku": sku,
                            "count": count,
                            "price": sku.price

                        })
                        break
                order.save()
            except serializers.ValidationError:
                raise
            except Exception:
                transaction.savepoint_rollback(save_id)
                raise

            # 提交事务
            transaction.savepoint_commit(save_id)
            # 清除购物车中已经结算的商品
            redis_conn.delete(‘cart2_%s‘ % user.id)
            return order

from django.db import transaction

@transaction.atomic
def viewfunc(request):
    # 这些代码会在一个事务中执行
    ...

from django.db import transaction

# 创建保存点
save_id = transaction.savepoint()  

# 回滚到保存点
transaction.savepoint_rollback(save_id)

# 提交从保存点到当前状态的所有数据库事务操作
transaction.savepoint_commit(save_id)