day02---sku商品管理

系统管理员 2022-12-11 02:28 158阅读 0赞

## 一： 获取SKU商品的列表： ##

<一>： 分析：分析前端返回的数据，我们需要先定义一个序列化器。序列化返回sku商品的信息。  
分析前端需要数据与模型类的字段，发现这几个需要自定义。

# 商品的属性：
    # "id": "商品SKU ID",
    # "name": "商品SKU名称",
    # "spu": "商品SPU名称", --->spu = models.ForeignKey  自动映射的会是id，需要自己定义
    # "spu_id": "商品SPU ID",  --->外键的隐藏字段，不会自动映射
    # "caption": "商品副标题",   --->category = models.ForeignKey, 自动映射的会是id ，需要自己定义
    # "category_id": "三级分类id", ---> 外键的隐藏字段，不会自动映射
    # "category": "三级分类名称",
    # "price": "价格",
    # "cost_price": "进价",
    # "market_price": "市场价格",
    # "stock": "库存",
    # "sales": "销量",
    # "is_launched": "上下架",
    # "specs": [
    #     {
        
    #         "spec_id": "规格id",---->没有这个字段，应该是从表的外键字段related_name = "spaecs"
    #         "option_id": "选项id"
    #     },

1：准备序列化器：  
新建并编辑`apps/meiduo_admin/serializers/sku_serializers.py`

sku = models.ForeignKey(SKU, related_name='specs', on_delete=models.CASCADE, verbose_name='sku')
    spec = models.ForeignKey(SPUSpecification, on_delete=models.PROTECT, verbose_name='规格名称')
     option = models.ForeignKey(SpecificationOption, on_delete=models.PROTECT, verbose_name='规格值')

class  SKUSpecOptModelSerializer(serializers.ModelSerializer):
        class Meta:
            model = SKUSpecification
            # 如果关联对象主键隐藏字段，我们在fields中显示声明，则会自动映射类型为ReadOnlyField —— 只读(只参与序列化)
            fields = [
                'spec_id',
                'option_id'
            ]

2：视图编写：

from rest_framework.viewsets import ModelViewSet
    from ..serializers.sku_serializers import *
    from ..paginations import MyPage
    
    class SKUGoodsView(ModelViewSet):
        queryset = SKU.objects.all()
        serializer_class = SKUModelSerializer
        pagination_class = MyPage
    
        def get_queryset(self):
            keyword = self.request.query_params.get('keyword')
            if keyword:
                return self.queryset.filter(name__contains=keyword)
            return self.queryset.all()

路由：由于这里使用的模型类是ModelViewSet,所以需要将get方法转换成list。

urlpatterns = [
        # ......
        # SKU管理
        re_path(r'^skus/$', SKUGoodsView.as_view({
        'get': 'list'})),
    ]

## 二：新增SKU三级分类：拿到sku的id大于37的数据： ##

1：序列化器：编辑`apps/meiduo_admin/serializers/sku_serializers.py`，序列化返回数据

class SKUCategorySimpleSerializer(serializers.ModelSerializer):
        class Meta:
            model = GoodsCategory
            fields = [
                'id',
                'name'
            ]

2：视图：编辑`apps/meiduo_admin/views/sku_views.py`

class SKUCategoryView(ListAPIView):
        queryset = GoodsCategory.objects.all()
        serializer_class = SKUCategorySimpleSerializer
    
        def get_queryset(self):
            # 过滤三级分类
            return self.queryset.filter(parent_id__gte=37)

3：路由：

urlpatterns = [
        # ......
       	# 新增SKU可选三级分类
        re_path(r'^skus/categories/$', SKUCategoryView.as_view()),
    ]

## 三：新增SKU可选的SPU： ##

1：序列化器：编辑`apps/meiduo_admin/serializers/sku_serializers.py`

class SPUSimpleSerializer(serializers.ModelSerializer):
        class Meta:
            model = SPU
            fields = [
                'id',
                'name'
            ]

2：视图：

re_path(r'^goods/simple/$', SPUSimpleView.as_view()),

## 四：SKU的可选规格和选项： ##

描述:当选择一个SPU商品的时候，前端会传递给服务器这个sup的id,服务器根据这个spu的id，查找该spu商品的规格和选项信息，序列化返回。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]  
<一>：分析：首先从序列化器入手，我们要定义一个序列化器序列化多个spu商品的规格，序列化的；同时还要序列化多个选项信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]  
1：定义商品规格表和选项表的序列化器：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]  
**分析返回的数据：id : 默认序列化，name : 正常序列化， spu : 是外键默认序列化返回id,所以需要自己指定使用string。 spu\_id : 商品id ,属于外键的隐藏字段，如果把他里加入fields 中，则不需要在外面再定义了。而options 是选项表的外键，他的spec的外键的related\_name 是options, 所以，需要调用选项模型类的序列化器。**  
编辑`apps/meiduo_admin/serializers/sku_serializers.py`

class SpecOptSimpleSerializer(serializers.ModelSerializer):
        class Meta:
            model = SpecificationOption
            fields = [
                'id',
                'value'
            ]
    
    class SPUSpecModelSerializer(serializers.ModelSerializer):
        spu = serializers.StringRelatedField()
        spu_id = serializers.IntegerField()
    
        # 关联从表SpecficationOption多条数据
        options = SpecOptSimpleSerializer(many=True)
    
        class Meta:
            model = SPUSpecification
            fields = [
                'id',
                'name',
                'spu',
                'spu_id',
                'options'
            ]

2：视图：  
编辑`apps/meiduo_admin/views/sku_views.py`  
<二>： 分析：因为此时要根据pk过滤，所以定义get\_queryset方法，返回过滤后的查询集，用来后续的序列化。

class SPUSpecView(ListAPIView):
        queryset = SKUSpecification.objects.all()
        serializer_class = SKUSpecOptModelSerializer
    
        def get_queryset(self):
    
            # 如何获取路径中的参数呢？这又不是视图中的函数？
            # 如果是命名分组使用： self.kwargs,  如果不是命名分组提取的参数，则使用self.args
            spu_id = self.kwargs.get("pk")
            return self.queryset.filter(spu_id=spu_id)

测试：  
![在这里插入图片描述][20200928095230965.png_pic_center]

## 五：新建SKU单一资源： ##

<分析>：现在要实现的是点击提交按钮，能够在后台建立一个SKU商品，由于我们视图继承ModelViewSet, 里面有cretae方法自动映射post方法，所以视图这里暂时完成了。接下来就是考虑序列化器能不能完成反序列化的操作呢？？  
对比这里好像都是完成了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]  
那么此时不妨映射路由测试一下：把post映射到create方法。

re_path(r'^skus/$', SKUGoodsView.as_view({
        'get': 'list', 'post': 'create'})),

![在这里插入图片描述][20200928100701477.png_pic_center]  
那么那里不能进行反序列化呢？？  
答：specs是隐藏字段，在进行新建的时候，传入的是中间表的数据，但是create方法只能操作自己的模型类，所以这里就出现了问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]  
1：如何解决这个问题呢？？？？？  
答：重写序列化器中的create方法：由原来的只插入主表数据，修改成两个表都插入。

class SKUModelSerializer(serializers.ModelSerializer):
        # 三个隐藏字段：
        # 1、本表主键id，会自动映射
        # 2、外间关联对象的主键隐藏字段(如：spu_id), 不会自动映射
        spu = serializers.StringRelatedField()
        spu_id = serializers.IntegerField()
        category = serializers.StringRelatedField()
        category_id = serializers.IntegerField()
    
        # 3、从表related_name指定的主表隐藏字段，不会自动映射
        specs = SKUSpecOptModelSerializer(many=True)
        class Meta:
            model = SKU
            fields = "__all__"
    
        def create(self, validated_data):
    
            # 将原来的specs, pop()出来
            specs = validated_data.pop("specs")
    
            # 创建主表数据
            sku = SKU.objects.create(**validated_data)
    
            # 新建从表数据
            for temp in specs:
                # 先加入sku_id这个键
                temp['sku_id'] = sku.id
                # 创建数据
                SKUSpecification.objects.create(**temp)
            return sku

2：解决es搜索服务问题：  
再次测试出现es搜索服务的问题：  
![在这里插入图片描述][20200928104129977.png_pic_center]  
出现的原因：我们之前的项目的SKU做过搜索服务，一旦sku商品信息有改动，就会触发Haystack,重新构建索引。解决问题：先注释掉：

# # Haystack配置项
    # HAYSTACK_CONNECTIONS = {
        
    #     # 默认的es服务器链接
    #     'default': {
        
    #         'ENGINE': 'haystack.backends.elasticsearch_backend.ElasticsearchSearchEngine',
    #         'URL': 'http://192.168.203.153:9200/', # Elasticsearch服务器ip地址，端口号固定为9200
    #         'INDEX_NAME': 'meiduo_mall', # Elasticsearch建立的索引库的名称
    #     },
    # }
    # 
    # # 当被检索的数据被修改了，haystack就会把新的数据写入es索引库
    # HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'
    # 
    # 
    # # 可以在 dev.py 中添加如下代码, 用于决定每页显示数据条数:
    # HAYSTACK_SEARCH_RESULTS_PER_PAGE = 5

然后注释中间件：等一系列关于es服务的报错。  
3：测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]  
![在这里插入图片描述][20200928105032460.png_pic_center]  
问题：当关联的是主表主键的隐藏字段时，fields中设置，默认映射时read\_only :只作用于序列化操作，不作用于反序列化。所以仍然需要自己定义。

class  SKUSpecOptModelSerializer(serializers.ModelSerializer):
        # 因为这2个字段必须参与反序列化，所有我们只能手动映射覆盖原有的默认映射(默认只作用于序列化)
        spec_id = serializers.IntegerField()
        option_id = serializers.IntegerField()
        class Meta:
            model = SKUSpecification
            fields = ['spec_id', 'option_id']

再次测试：成功！！！！  
![在这里插入图片描述][20200928105846659.png_pic_center]  
![在这里插入图片描述][20200928105928120.png_pic_center]  
4：增加事务：

此时还有一个问题：两个表必须同时新建，不能主表新建成功，从表不能新建这种情况。所以要增加事务。

def create(self, validated_data):
    
            # 将原来的specs, pop()出来
            specs = validated_data.pop("specs")
    
            with transaction.atomic():
                save_id = transaction.savepoint()
                try:
    
                    # 创建主表数据
                    sku = SKU.objects.create(**validated_data)
    
                    # 新建从表数据
                    for temp in specs:
                        # 先加入sku_id这个键
                        temp['sku_id'] = sku.id
                        # 创建数据
                        SKUSpecification.objects.create(**temp)
                except Exception as e:
                    transaction.savepoint_rollback(save_id)
                    raise serializers.ValidationError("数据库连接失败")
    
                transaction.savepoint_commit(save_id)
    
            return sku

## 六：修改SKU单一资源： ##

<一>分析：  
修改操作，我们采用全更新，首先需要后端返回这个商品的数据，然后用户修改后，再更新数据。  
1：序列化返回单一资源：  
视图已经完成了，接下来是路由：

re_path(r'^skus/(?P<pk>\d+)/$', SKUGoodsView.as_view({
        'get':'retrieve'})),

2：测试：点击修改，返回这个信息，说明成功。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]  
3：点击提交后，提交的是put放方法,所以路由先映射一下：

re_path(r'^skus/(?P<pk>\d+)/$', SKUGoodsView.as_view({
        'get':'retrieve', "put": "update"})),

4：序列化器能不能完成更新操作呢？  
答：跟刚才一样，create方法不能新建中间表数据，update方法也不行，需要自己在序列化器中重新定义。

def update(self, instance, validated_data):
            # 将原来的specs, pop()出来
            specs = validated_data.pop("specs")
    
            # 更新主表数据：调用父类的update方法进行更新
            sku = super().update(instance, validated_data)
    
            # 删除原来中间表的数据
            SKUSpecification.objects.filter(sku_id=sku.id).delete()
    
            # 新建新的数据
            for temp in specs:
                temp['sku_id'] = sku.id
                SKUSpecification.objects.create(**temp)
                
            return sku

## 七：删除sku单一资源： ##

只需要修改路由：

re_path(r'^skus/(?P<pk>\d+)/$', SKUGoodsView.as_view({
        'get':'retrieve', "put": "update", "delete": "destroy"})),

## 八：异步任务： ##

需求：当后台管理人员新建一个sku商品的时候，需要后台渲染这个商品的静态化页面，此时采用异步任务：  
1：序列化器调用异步任务：

class SKUModelSerializer(serializers.ModelSerializer):
    ...
                transaction.savepoint_commit(save_id)
    
            # TODO: 使用异步任务方式，静态化生成当前新建sku商品的详情页
            generate_static_sku_detail_html.delay(sku.id)
    
            return sku

2：新建文件`celery_tasks/html/tasks.py`，编辑如下：

import os
    from django.template import loader
    from django.conf import settings
    from apps.goods.utils import get_categories,get_goods_and_spec
    from celery_tasks.main import celery_app
    
    @celery_app.task(name='generate_static_sku_detail_html')
    def generate_static_sku_detail_html(sku_id):
        categories = get_categories()
        goods, sku, specs = get_goods_and_spec(sku_id)
    
        # =========模版渲染========
        template = loader.get_template('detail.html')
        context = {
        
            'categories': categories,
            'goods': goods,  # 当前sku从属的spu
            'specs': specs,  # 规格和选项信息
            'sku': sku  # 当前sku商品对象
        }
        page = template.render(context)
    
        # settings.STATIC_FILE_PATH --> 是front_end_pc文件夹路径
        file_path = os.path.join(
            settings.STATIC_FILE_PATH,
            'goods/%d.html' % sku_id, # 'goods/1.html'
        )
    
        with open(file_path, 'w') as f:
            f.write(page)

3：将taskts注册到main 函数中：

celery_app.autodiscover_tasks(['celery_tasks.sms', 'celery_tasks.email', 'celery_tasks.html'])

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/325a1323cb1b43f7872ac69e3d6498d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/501704092794449c931247ece85fa4ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c6b7b7f5eb6647c0b64087fc39cf3ee6.png
[20200928095230965.png_pic_center]: /images/20221123/283f7b4927354ddeb95e6d9cb5d35865.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/a12d586613a24d5ba1d9b404f7e33198.png
[20200928100701477.png_pic_center]: /images/20221123/e441cdba28c946f788438375736e1e00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/a51667954cd041f98faa897133d5d4d6.png
[20200928104129977.png_pic_center]: /images/20221123/79ad44b1f1f645d7b1deda98e87c9183.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/41a0d5b91ad54524aa5f681a8e09702f.png
[20200928105032460.png_pic_center]: /images/20221123/1b930c62f4b444e3adedf0c09c11112d.png
[20200928105846659.png_pic_center]: /images/20221123/d3efa73ab2874e389b67550a3420d173.png
[20200928105928120.png_pic_center]: /images/20221123/cec2366568a342f38dd0ccd4fa9c9ca1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/dee31806c0ca42bbb35a6f0fb045464c.png