Django商城前台项目

妖狐艹你老母 2023-01-01 01:50 120阅读 0赞

### 目录 ###

*   *  1： 项目初始化
     *   *  1.1: 虚拟环境命令：
         *  1.2： Django项目的创建
         *  1.3： manage.py 中指定运行的配置文件地址：
         *  1.4：BASE\_DIR问题：
         *  1.5： 指定模板文件夹的位置：
         *  1.6：Mysql数据库的配置
         *  1.7： 配置Redis
         *  1.8： 配置日志：
         *  1.9：主机域名映射和设置django白名单：
         *  1.10： django创建子应用：
     *  2：Django RESTful 设计风格
     *   *  2.1：HTTP接口/Web接口/网络API
         *  2.2：Django Restful设计风格：
     *  3：用户模型类的设计
     *   *  3.1： Django自带的用户模型类：
         *  3.2：自定义模型类继承于Django自己的模型类：
         *  3.3：模型类迁移建表：
     *  4：跨域问题
     *   *  4.1： 什么是同源？
         *  4.2： 什么是同源策略：
         *  4.3： Django如何解决跨域问题？
     *  5: 用户注册模块
     *   *  5.1: 用户名重复注册：
         *  5.2: 判断手机号是否重复注册
         *  5.3: 用户注册接口
         *  5.4: CSRF防护的问题：
         *  5.5: 注册后的状态保持：
         *  5.6： 图片验证码：
         *  5.7: 短信验证码：
     *  6：异步任务：
     *   *  6.1：生产者消费者模式：
         *  6.3：Celery框架：
         *  6.3： 短信验证码实现异步任务：
     *  7：账号登录
     *   *  7.1: 用户名登录
         *  7.2: 多账号登录
         *  7.3:首页用户名展示 ，退出登录
         *  7.5： 登录后的认证：
         *  7.4: QQ登录
     *  8：itsdangerous加密模块对openid进行加密生成带有有效期的tocken
     *  9： 用户基本信息展示与修改
     *   *  9.1: 用户基本信息展示：
         *  9.2：修改密码：
     *  10：邮箱认证
     *  11：收货地址
     *   *  11.0: 省市区三级联动：
         *  11.1： 新增收货地址
         *  11.2：展示收货地址
         *  11.3：修改收货地址
         *  11.4：删除收货地址
         *  11.5：设置默认的收货地址和修改地址标题
     *  12： 缓存策略
     *  13：商品模块---FastDFS文件存储系统
     *  14：Docker工具的使用：
     *  15：项目使用docker运行FASTDFS
     *  16：Django的文件存储后端
     *  17：页面静态化理论
     *   *  17.1： 首页静态化
         *  17.2：使用定时任务执行页面静态化
         *  17.3：商品详情页静态化
     *  18： 脚本执行方式：
     *  19：商品列表页
     *   *  19.1：商品列表页思路：
         *  19.2： 分页：
         *  19.3: 列表页热销排行：
     *  20：ES搜索引擎的使用（Elasticsearch）7.6.2（版本）
     *   *  20.1：ES搜索引擎的原理？（全文检索）
         *  20.2：使用Docker快速搭建ES搜索引擎：
     *  21：Haystack扩展建立索引
     *  22：浏览历史记录模块
     *   *  22.1： 增加浏览历史记录：
         *  22.2: 查看用户浏览历史记录：
     *  23：pickle和base64模块进行编解码
     *  24：购物车模块
     *   *  24.1： 添加购物车
         *  24.2： 展示购物车
         *  24.3： 修改购物车
         *  24.4：删除购物车
         *  24.5：全选购物车
         *  24.6：合并购物车：
         *  24.8：购物车页面的展示：
     *  25： 订单模块
     *   *  25.1： 新建保存订单：
         *  25.2： 乐观锁下单：
         *  25.3： 结算页面：
     *  26： 支付宝支付接口：
     *   *  26.1： 对称加密和非对称加密：
         *  26.2: 商城后端和支付宝之间互换公钥：
         *  16.3: 返回支付宝的支付链接：
         *  16.4:支付成功与订单绑定：

## 1： 项目初始化 ##

### 1.1: 虚拟环境命令： ###

*  创建虚拟环境： mkvirtualenv 项目名 -p python3
 *  进入虚拟环境：workon 虚拟环境名
 *  退出虚拟环境：deactivate

### 1.2： Django项目的创建 ###

*  django-admin startproject 项目名
 *  进入Django环境下的python环境：python3 manage.py shell
 *  静态服务器的开启： python3 -m http.server 8080
 *  创建子应用： python3 manage.py startapp 应用名

### 1.3： manage.py 中指定运行的配置文件地址： ###

*      os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'meiduo_mall.settings.dev')

### 1.4：BASE\_DIR问题： ###

*  `os.path.abspath(__file__)`： 这个是取当前文件的绝对路径。
 *  `os.path.dirname()`： 这个是取绝对路径的上层目录。
 *  `os.path.join('', '')`: 这个是拼接路径。

### 1.5： 指定模板文件夹的位置： ###

*  1：在配置文件中Templates配置项下配置模板的信息。
 *  2：`'DIRS': [os.path.join(BASE_DIR,"templates")],`指定模板文件夹的路径。

### 1.6：Mysql数据库的配置 ###

*  创建数据库： create database 数据库名 charset=utf8;
 *  创建用户：create user 用户名 identified by ‘密码’;
 *  授予这个用户所有的权限：grant all on 用户名.\* to ‘数据库名’@’%’;
 *  刷新权限：flush privileges;

DATABASES = {
        
        'default': {
        
            'ENGINE': 'django.db.backends.mysql',
            'NAME': "meiduo_mall",
            'USER':'itcast',
            'PASSWORD':'123456',
            'HOST':'192.168.203.153',
        }
    }

### 1.7： 配置Redis ###

*  在配置文件中增加信息：

CACHES = {
        
        # 默认存储信息: 存到 0 号库
        "default": {
         
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://127.0.0.1:6379/0",
            "OPTIONS": {
        
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
            }
        },
        # session 信息: 存到 1 号库
        "session": {
         
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://127.0.0.1:6379/1",
            "OPTIONS": {
        
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
            }
        },
    }
    # 指定Session的引擎
    SESSION_ENGINE = "django.contrib.sessions.backends.cache"
    # 指定存储Session数据的存储引擎
    SESSION_CACHE_ALIAS = "session"

### 1.8： 配置日志： ###

*  1：django的模板日志放在配置项中：
 *  2：修改配置项信息。
 *  3：日志的使用：

# 日志的使用：
    # 1: 导入logging
    # 2: 创建日志器
    # 3： 使用日志器向日至文件中写入数据
    import logging
    
    logger = logging.getLogger('django')
    
    logger.debug('')
    logger.info('')
    logger.error('')

*  4：日志的配置文件

LOGGING = {
        
        'version': 1,
        'disable_existing_loggers': False,  # 是否禁用已经存在的日志器
        'formatters': {
          # 日志信息显示的格式
            'verbose': {
        
                'format': '%(levelname)s %(asctime)s %(module)s %(lineno)d %(message)s'
            },
            'simple': {
        
                'format': '%(levelname)s %(module)s %(lineno)d %(message)s'
            },
        },
        'filters': {
          # 对日志进行过滤
            'require_debug_true': {
          # django在debug模式下才输出日志
                '()': 'django.utils.log.RequireDebugTrue',
            },
        },
        'handlers': {
          # 日志处理方法
            'console': {
          # 向终端中输出日志
                'level': 'INFO',
                'filters': ['require_debug_true'],
                'class': 'logging.StreamHandler',
                'formatter': 'simple'
            },
            'file': {
          # 向文件中输出日志
                'level': 'INFO',
                'class': 'logging.handlers.RotatingFileHandler',
                'filename': os.path.join(BASE_DIR, 'logs/meiduo.log'),  # 日志文件的位置
                'maxBytes': 300 * 1024 * 1024,
                'backupCount': 10,
                'formatter': 'verbose'
            },
        },
        'loggers': {
          # 日志器
            'django': {
          # 定义了一个名为django的日志器
                'handlers': ['console', 'file'],  # 可以同时向终端与文件中输出日志
                'propagate': True,  # 是否继续传递日志信息
                'level': 'INFO',  # 日志器接收的最低日志级别
            },
        }
    }

*  5： python日志的几个级别：debug（开发阶段）, info(上线后), warning（警告）, error（错误）, critical(系统崩溃)
 *  设置日志级别之后，则只记录等于或者高于级别的日志信息。

### 1.9：主机域名映射和设置django白名单： ###

*  vim /etc/hosts
 *  增加： 127.0.0.1 www.meiduo.site
 *  在配置文件中，找到：
    
        ALLOWED_HOSTS = [] # 只有在这个白名单中域名的才能访问django
        ALLOWED_HOSTS = ["*"] # 所有域名均可访问。

### 1.10： django创建子应用： ###

*  命令：python3 manage.py startapp 应用名
 *  创建子路由：新建urls.py
    
        urlpatterns = [
            
        ]
 *  在配置文件中注册子应用：
    
        INSTALLED_APPS = [
            # 以外层目录为导包路径，users在app下的users中
            'apps.users',
        ]
 *  应用的目录：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tDzeG6b8-1609312736789)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201222103311904.png)\]

## 2：Django RESTful 设计风格 ##

### 2.1：HTTP接口/Web接口/网络API ###

*  请求方式： GET， POST， PUT， DELETE
 *  协议，域名，端口，请求路径：http/https: 127.0.0.1 : 8000 /login
 *  请求参数 :查询字符串参数，路径参数，请求头参数，请求体（表单格式，json格式）。
 *  响应数据

### 2.2：Django Restful设计风格： ###

*  请求路径采用**名词复数**（对应数据库中的表）
 *  请求方式表示动作。get: 获取资源，post:新增资源， put :更新资源， delete:删除资源。

## 3：用户模型类的设计 ##

### 3.1： Django自带的用户模型类： ###

*  django自己定义的模型类在：django,contrib.auth中。
 *  这个包中的AbstractUser定义了一些User的基本信息。

### 3.2：自定义模型类继承于Django自己的模型类： ###

1： 定义模型类：

from django.db import models
    from django.contrib.auth.models import AbstractUser
    
    class User(AbstractUser):
        
        mobile = models.CharField(max_length=11, unique=True, verbose_name="手机号")
        class Meta:
            db_table = "tb_users"
            
        def __str__(self):
            return self.username

2： 告诉django使用我们自己的模型类，不使用AbstractUser:

注意的是： 配置自己的应用只能使用格式： ‘应用名.User’，但是users，项目能够找到吗？

# 配置文件中增加信息
    AUTH_USER_MODEL = 'users.User'

3：要想能够找到users，则只需要将users上层的目录设置成导包路径就可以了。

即：设置app为导包路径：注意sys.path里面的都是导包路径。

# 配置文件设置：BASE_DIR是内层目录，os.path.dirname取上层目录：外层目录，注意拼接不用/apps,直接使用‘apps’
    
    # 注意，这个语句必须放在BASE_DIR之后。
    import sys
    sys.path.insert(
        0,os.path.join(os.path.dirname(BASE_DIR),"apps")
    )

### 3.3：模型类迁移建表： ###

*  python3 manage.py makemigrations
 *  python3 manage.py migrate

## 4：跨域问题 ##

场景：来自8080服务器的js中的动态接口请求，不能发送给8000端口。

### 4.1： 什么是同源？ ###

答： 协议，域名，端口相同属于同源。

浏览器判断是否是同源的规则：判断协议域名端口的字面值：字符串是否完全一致。

注意：http://www.meiduo.site:8000和 http://127.0.0.1:8000, 这俩也非同源的。

### 4.2： 什么是同源策略： ###

*  1： 浏览器访问8080拿到我们的JS文件，JS文件中的动态请求需要访问我们的8000端口。
 *  2： 浏览器会先向我们的8000端口发送options请求，询问8000端口我能否访问？
 *  3：django默认是不允许的，因此无法访问我们的8000端口。

### 4.3： Django如何解决跨域问题？ ###

*  1： 安装跨域包（django-cors-headers）：pip install django-cors-headers -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  2：注册安装包中的 corsheaders应用：
    
        # 配置文件中：
        INSTALLED_APPS = [
            # 跨域问题
            'corsheaders',
        ]
 *  3：添加跨域中间件：
    
        # 配置文件中
        MIDDLEWARE = [
            # 跨域中间件
            'corsheaders.middleware.CorsMiddleware',
        ]
 *  4： 跨域白名单：
    
        # CORS跨域请求白名单设置
        CORS_ORIGIN_WHITELIST = (
            'http://127.0.0.1:8080',
            'http://localhost:8080',
            'http://www.meiduo.site:8080',
        )
        CORS_ALLOW_CREDENTIALS = True  # 允许携带cookie
        ALLOWED_HOSTS = ["*"]

## 5: 用户注册模块 ##

### 5.1: 用户名重复注册： ###

*  前端路径传参，视图函数需要username接收参数。
 *  子路由需要对用户名进行正则匹配。
 *  查询数据库需要捕获异常。

1： 视图代码：查询数据库操作一般需要捕获一下异常。

from django.http import JsonResponse
    from django.views import View
    from apps.users.models import User
    
    class UsernameCountView(View):
        def get(self, request, username):
            try:
                count = User.objects.filter(username=username).count()
            except Exception as e:
                return JsonResponse({
        
                    "code": 0,
                    'errmsg': '数据库出错'
                })
            return JsonResponse({
        
                'code': 0,
                'errmsg': 'ok',
                'count': count,
            })

2： 编写子路由：

from django.urls import re_path
    
    from apps.users import views
    
    urlpatterns = [
        re_path(r"^usernames/(?P<username>[A-Za-z0-9_-]{5,20})/count/$", views.UsernameCountView.as_view()),
    ]

3：将子路由加入总路由：注意include的使用：

from django.contrib import admin
    from django.urls import include
    from django.urls import path
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path("", include("apps.users.urls")),
    ]

4： 创建superuser进行测试

*  python3 manager.py createsuperuser

### 5.2: 判断手机号是否重复注册 ###

*  Get请求
 *  路径传参

1：视图代码：

class MobilePhoneCountView(View):
        # 判断手机号是否注册
        def get(self, request, mobile):
            try:
                count = User.objects.filter(mobile=mobile).count()
            except Exception as e:
                return JsonResponse({
        
                    "code": 0,
                    "errmsg": "数据库出错"
                })
            return JsonResponse({
        
                "coed": 0,
                "errmsg": "ok",
                "count": count
            })

2： 路由代码：

# 2: 判断手机号是否重复注册
    re_path(r"^mobiles/(?P<mobile>1[3-9]\d{9})/count/$",views.MobilePhoneCountView.as_view()),

### 5.3: 用户注册接口 ###

*  请求方式：POST
 *  请求路径： /register/
 *  请求参数：用户名，密码，确认密码，手机号，是否接收许可，短信验证码。（请求体携带）
 *  响应：code : 0 成功。 code : 400失败。

1： 业务实现逻辑：

"""
    1： 提取参数（请求体： request.body.decode()---> json.loads()转换成字典）
    2： 校验参数： 必要性校验和单独字段校验。
    必要性校验： 都必须填。
    单独字段校验：用户名格式，手机号格式，密码两次是否一致，是否接受许可。
    3： 业务处理：数据库创建用户。
    4： 构建响应。
    """

2： 视图：

class registerView(View):
        # 用户注册接口的实现:
        def post(self, request):
            # 1: 提取参数
            data = request.body.decode() # 二进制解码
            data_dict = json.loads(data) # json转换成字典
            username = data_dict.get('username') # 这里使用get方式获取，不能使用[]不让他报错
            password = data_dict.get('password')
            password2 = data_dict.get('password2')
            mobile = data_dict.get('mobile')
            sms_code = data_dict.get('sms_code')
            allow = data_dict.get("allow", False)
    
            # 2: 校验参数
            if not all([username, password, password2, mobile, sms_code, allow]):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "参数缺失"
    
                })
    
            # 单独字段校验---校验用户名
            if not re.match(r'^[A-Za-z0-9_-]{5,20}$', username):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "用户名格式不正确"
                })
            # 校验密码格式是否正确：
            if not re.match(r'^[a-zA-Z0-9]{8,20}$', password):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "密码的格式有误"
                })
            # 校验两次密码是否正确
            if password2 != password:
                return JsonResponse({
        
                    "code": 400,
                    'errmsg': "两次密码输入的不一致，请重新输入"
                })
    
            # 校验手机号格式是否正确
            if not re.match(r'^1[3-9]\d{9}$', mobile):
                return JsonResponse({
        
                    "code":400,
                    "errmsg": "手机号格式错误"
                })
    		# 校验许可是否允许
            if not allow:
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "未签署许可条约"
                })
    
            # 3： 数据处理
            try:
                user = User.objects.create_user(username=username, password=password, mobile=mobile)
            except Exception as e:
                return JsonResponse({
        
                    "code": 500,
                    "errmsg": "数据库错误"
                })
            # 4:构建响应：
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })

2: 路由：

urlpatterns = [
        re_path(r"^register/$", views.registerView.as_view()),
    ]

3: 短信验证码的补充：

# 校验短信验证码是否正确：
            conn = get_redis_connection('verify_code')
            sms_code_from_redis = conn.get("sms_%s" % mobile)
            if sms_code_from_redis.decode() != sms_code:
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "短信验证码错误"
                })

### 5.4: CSRF防护的问题： ###

*  对于post请求，django的csrf防护的中间件会阻止提交。
 *  解决方案：取消中间件

MIDDLEWARE = [
        # 'django.middleware.csrf.CsrfViewMiddleware',
    ]

### 5.5: 注册后的状态保持： ###

*  1： 开启redis ： redis-server
 *  2：在注册的末尾增加： login(request, user)
 *  3: 这句话做了什么？答：帮我们把用户信息写入到Session中，并把Sessionid保存到cookie中。

### 5.6： 图片验证码： ###

*  1：图片验证码的业务逻辑：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EuMCRdMd-1609312736799)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201222152326633.png)\]
 *  2：创建verifications子应用：
 *  3：安装pillow图片库：pip install Pillow -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  4： 增加一个redis数据库，将图片验证码存储在那个库中。
    
        # 验证码信息: 存到 2 号库
            "verify_code": {
                
                "BACKEND": "django_redis.cache.RedisCache",
                "LOCATION": "redis://192.168.203.153:6379/2",
                "OPTIONS": {
              
                    "CLIENT_CLASS": "django_redis.client.DefaultClient",
                }
            },
 *  5：视图的编写：
    
        # 首先前端会传递给我一个uuid(路径参数)。
        # 1：提取参数（路径传参无需）
        # 2：校验参数（路由uuid匹配，无需校验）
        # 3：业务处理（用pillow图片库生成图片和验证码，将验证码写入redis数据库中，返回图片（指定格式为jpeg）） 
        
        from django.http import HttpResponse
        from django.http import JsonResponse
        from django.views import View
        
        from apps.verifications.libs.captcha.captcha import captcha
        from django_redis import get_redis_connection
        
        class ImageCodeView(View):
            def get(self, request, uuid):
                # 1: 利用图片库生成图片和text
                text , image = captcha.generate_captcha()
                # 2: 将text写入到redis数据库中
                try:
                    conn = get_redis_connection('verify_code')
                    conn.setex(
                        'img_%s' % uuid,  # img_fhjeiuw-fewfer-frewfrg
                        300,  # 300秒有效期
                        text  # "ABCD"
                    )
                except Exception as e:
                    return JsonResponse({
              
                        "code": 500,
                        "errmsg": "redis数据库错误"
                    })
        
                # 3： 返回图片,指定图片格式是jpeg
                return HttpResponse(image, content_type="image/jpeg")
 *  6： 路由的映射：
    
        from django.urls import path
        
        from verifications import views
        
        urlpatterns = [
            path('^image_codes/<uuid:uuid>/$', views.ImageCodeView.as_view()),
        ]

### 5.7: 短信验证码： ###

*  1： 云通讯的配置信息：
    
        """
        主账户ID :8a216da873cec13201744db8f9b1325a
        账户授权令牌：e6128f3209c843cabe657685bde6c222
        APPID : 8a216da873cec13201744db8fb0d3261
        """
 *  2：将云通讯的包导入到verifications下的lib文件下。
    
    修改云通讯下面的配置信息：ccp\_sms.py
    
        # 说明：主账号，登陆云通讯网站后，可在"控制台-应用"中看到开发者主账号ACCOUNT SID
        _accountSid = '8a216da873cec13201744db8f9b1325a'
        
        # 说明：主账号Token，登陆云通讯网站后，可在控制台-应用中看到开发者主账号AUTH TOKEN
        _accountToken = 'e6128f3209c843cabe657685bde6c222'
        
        # 请使用管理控制台首页的APPID或自己创建应用的APPID
        _appId = '8a216da873cec13201744db8fb0d3261'
 *  3：编写视图函数：
    
        """
        短信验证码的视图逻辑：
        # 1： 路径中有手机号码（视图函数接收）， 查询字符串参数有两个image_code : 图片验证码，image_code_id : 图片验证码的唯一id。
        
        # 2： 校验参数：（必要性校验 + 图形验证码校验 + uuid校验）
         处理之外： 图形验证码还要和用户手写的进行比对
         
        # 3： 业务处理：生成短信验证码--->存入redis数据库--->调用容联云发送。
        """
    
        # 短信验证码生成
        class SMSCodeView(View):
            def get(self, request, mobile):
        
                # 1: 提取参数
                image_code = request.GET.get('image_code')
                uuid = request.GET.get("image_code_id")
        
                # 2: 校验参数
                if not all([image_code, uuid]):
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "参数缺失"
                    })
                # 校验图片验证码的格式
                if not re.match(r'^[a-zA-Z0-9]{4}$', image_code):
                    return JsonResponse({
              
                        'code': 400,
                        'errmsg': '图形验证码格式有误！'
                    }, status=400)
                # 校验图片验证码的uuid
                if not re.match(r'^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$', uuid):
                    return JsonResponse({
              
                        'code': 400,
                        'errmsg': 'uuid不符合格式'
                    }, status=400)
        
                # 图片验证码和redis数据库中的是否一致
                conn = get_redis_connection('verify_code')
                image_code_from_redis = conn.get("img_%s" % uuid)
                if not image_code_from_redis: # 验证码过期了
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "验证码过期了"
                    })
                image_code_from_redis = image_code_from_redis.decode() # 字节类型转换成字符串类型
        
                if image_code.lower() != image_code_from_redis.lower():
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "验证码有误"
                    })
        
        
                # 3： 业务处理：---发送短信验证码
                # 生成6位的短信验证码
                sms_code = "%06d" % randint(0, 999999)
                # 将短信验证码写入redis数据库
                conn.setex("sms_%s" % mobile, 600, sms_code)
                # 调用容联云发送短信验证码
                CCP().send_template_sms(mobile, [sms_code, 10], 1)
        
                return JsonResponse({
              
                    "code": 0,
                    "errmsg": "ok"
                })
 *  4：删除图片验证码（解决频发发送验证码的问题）
    
        """
        图形验证码写错了，请求了，这个图片验证码就不能再用了。如果不设置只能用一次那么，爬虫就会一直尝试。不安全。怎么做？读一次删一次。 
        """
        # 图片验证码和redis数据库中的是否一致
        conn = get_redis_connection('verify_code')
        image_code_from_redis = conn.get("img_%s" % uuid)
        # 删除图片验证码保证只能使用一次。
        conn.delete('img_%s' % uuid)
 *  5：增加标志位（解决频繁发送验证码的问题）
    
        """
        现在的代码，如果用户填写正确，能够多次的发送验证码，怎样解决这个问题呢？
        答：设计一个标志位，跟随短信验证码一起写入数据库，再次访问的时候首先判断这个标志位是否存在，如果存在则直接返回响应，让用户等待。
        """
    
    主要看send\_flag的作用：
    
        # 3： 业务处理：---发送短信验证码
                send_flag = conn.get('send_flag_%s' % mobile)
                if send_flag:
                    return JsonResponse({
              'code': 400, 'errmsg': '请勿重复发送'}, status=403)
                # 生成6位的短信验证码
                sms_code = "%06d" % randint(0, 999999)
                # 将短信验证码写入redis数据库
                conn.setex("sms_%s" % mobile, 600, sms_code)
                # 增加一个标志
                conn.setex("send_flag_%s" % mobile, 60, '1')
                # 调用容联云发送短信验证码
                CCP().send_template_sms(mobile, [sms_code, 10], '1')
 *  6： 管道的使用（优化redis数据库）：
    
        """
        为了保证标志位和短信验证码同时存入数据库，则可以使用管道。
        注意：pl.setex()只是将命令加入管道，并不执行。
        pl.execute()是将管道内的命令一起执行。
        
        管道的执行原理：队列。队列是先进先出，保证了命令的顺序执行。Redis是CS架构，客户端与服务端之间通信是通过TCP通信，连接需要经过三次握手和四次挥手。为了提高效率，我们可以将多个执行放在一个TCP报文中执行。
        """
    
        pl = conn.pipeline()
                # 将短信验证码写入redis数据库
                pl.setex("sms_%s" % mobile, 600, sms_code)
                # 增加一个标志
                pl.setex("send_flag_%s" % mobile, 60, '1')
                pl.execute()

## 6：异步任务： ##

### 6.1：生产者消费者模式： ###

*  1： 生产者负责发布任务
 *  2： 消费者负责接收任务
 *  3：中间人就是消息队列，负责存储任务。

### 6.3：Celery框架： ###

*  是一个可以处理大量消息的分布式系统，可以运行在一台/多台上。
 *  celery的官方文档：http://docs.celeryproject.org/en/latest/index.html
 *  安装：pip install Celery -i https://pypi.tuna.tsinghua.edu.cn/simple

### 6.3： 短信验证码实现异步任务： ###

*  短信验证码出现的问题：
    
        """
        由于容联云接口依赖网络，如果发送容联云一直不响应，那么就导致我的django程序一直堵塞在这里，这样就会频繁给容联云发送请求。给前端带来的效果就是点击注册之后一直无法响应，页面一直不动，也不会出现倒计时。
        """
 *  如何实现异步任务？？？
    
    首先先建立这样的几个文件：
    
    在整个项目中建立一个celery\_tasks的文件夹，专门处理异步任务。然后在cleary里面建立，config.py 用于Celery的存储配置文件，main.py负责创建cleary对象，加载配置文件，自动捕获某个文件夹下面的名为tasks.py的文件。
    
    如图：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZiGCxTqa-1609312736801)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201222195809150.png)\]

main.py:

from celery import Celery
    
    # 1：创建celery对象
    celery_app = Celery("meiduo")
    # 2：加载配置文件
    celery_app.config_from_object('celery_tasks.config')
    # 3： 设置自动捕获tasks.py中的任务
    celery_app.autodiscover_tasks(['celery_tasks.sms'])

config.py:

broker_url='redis://192.168.203.153:6379/3'

tasks.py:

from celery_tasks.main import celery_app
    from celery_tasks.yuntongxun.ccp_sms import CCP
    
    
    @celery_app.task(name='ccp_send_sms_code')
    def ccp_send_sms_code(mobile, sms_code):
        '''该函数就是一个任务, 用于发送短信'''
        result = CCP().send_template_sms(mobile,[sms_code, 5],1)
        return result

最后修改短信验证码的调用方式：

# 调用容联云发送短信验证码
    # CCP().send_template_sms(mobile, [sms_code, 10], '1')
    from celery_tasks.sms.tasks import ccp_send_sms_code
    ccp_send_sms_code.delay(mobile, sms_code)

最后执行的命令：

*  celery -A celery\_tasks.main worker -l info
 *  注意启动的时候要在celery\_tasks所在的目录里启动。

## 7：账号登录 ##

### 7.1: 用户名登录 ###

*  判断用户名密码：
 *  user = authenticate(request, username=username, password=password)
 *  设置Session有效期
 *  request.session.set\_expiry(None) \# 两周有效

"""
    接口分析：
    # 1：提取参数：用户名和密码（request.body.decode()）
    # 2: 校验参数：（存在性校验 + 用户名校验 + 密码格式校验）
    # 3： 业务处理： 根据用户名查询用户，检验密码是否正确。
    # 4： 验证通过后进行状态保持
    """

# 用户名登录
    class LoginView(View):
        def post(self, request):
            # 1: 提取参数
            data = request.body.decode()
            data_dict = json.loads(data)
            username = data_dict.get('username')
            password = data_dict.get('password')
            remembered =  data_dict.get('remembered')
    
            # 2: 校验参数
            if not all([username, password]):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "缺失参数"
                })
            # 单独字段校验---校验用户名
            if not re.match(r'^[A-Za-z0-9_-]{5,20}$', username):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "用户名格式不正确"
                })
            # 校验密码格式是否正确：
            if not re.match(r'^[a-zA-Z0-9]{8,20}$', password):
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "密码的格式有误"
                })
    
            # 3： 逻辑处理
            from django.contrib.auth import  authenticate
            user = authenticate(request, username=username, password=password)
            if user is None:
                return JsonResponse({
        
                    "code": 400,
                    "errmsg": "用户名和密码错误"
                })
            # 进行状态保持
            login(request, user)
            # 判断是不是记住用户，如果记住用户则session设置两周有效，如果不是则立刻失效
            if remembered:
                request.session.set_expiry(None) # 两周有效
            else:
                request.session.set_expiry(0) # 立刻失效
    
            return JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })

### 7.2: 多账号登录 ###

"""
    我们的认证后端是django自己封装的，如何实现多账号登录呢？
    答：我们需要自定义认证后端实现多账号的登录。
    """

# 在指定的位置定义自定义后端
    from django.contrib.auth.backends import ModelBackend
    from django.db.models import Q
    from apps.users.models import User
    class LoginBackend(ModelBackend):
        def authenticate(self, request, username=None, password=None, **kwargs):
            try:
                user = User.objects.get(Q(username=username)|Q(mobile=username))
            except Exception as e:
                return None
            if user.check_password(password):
                return user

# 在配置文件中指定使用我们自己的认证后端：
    AUTHENTICATION_BACKENDS = ['apps.users.utils.LoginBackend']

### 7.3:首页用户名展示 ，退出登录 ###

1: 首页用户名展示：

"""
    首页用户名展示业务逻辑：
    如果想要登录后首页展示用户名，则需要将用户的名字，添加到cookie中，这样前端能够在cookie中拿到进行展示。
    """
    response = JsonResponse({
        "code": 0, "errmsg": "ok"})
            # 首页用户名展示：
            response.set_cookie('username', user.username, max_age=3600 * 24 * 14)
            return response

2：退出登录：

"""
    退出登录的业务逻辑：
    1： 清除掉后端的session
    2： 清除掉前端的cookie
    """

# 用户退出登录：
    class LogoutView(View):
        def delete(self, request):
            # 1: 清除后端的session
            from django.contrib.auth import logout
            logout(request)
            # 2: 清除前端的cookie
            response = JsonResponse({
        
                "code": 0,
                "errmsg": "ok"
            })
            response.delete_cookie('username')
            return response

# 5: 用户退出登录
        re_path(r"^logout/$", views.LogoutView.as_view()),

### 7.5： 登录后的认证： ###

*  之后只要是必须登录的直接继承这个视图就可以了。

from django.contrib.auth.mixins import LoginRequiredMixin
    from django.http import JsonResponse
    
    class LoginRequiredJSONMixin(LoginRequiredMixin):
        def handle_no_permission(self):
            # 该函数返回值就是没有登陆的时候，视图的返回
            return JsonResponse({
        'code': 400, 'errmsg': '未登陆'}, status=401)

### 7.4: QQ登录 ###

*  登录的业务逻辑：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2AnJEwNW-1609312736804)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201224095706529.png)\]

*  1： 创建一个应用auth专门处理第三方登录：
 *  2：创建模型类的基类，每个模型类肯定都有创建时间和更新时间，因此我们需要创建一个基类，其他的类继承基类就可以了。
    
        from django.db import models
        
        class BaseModel(models.Model):
            """为模型类补充字段"""
            # 创建时间:auto_now_add:创建或添加对象时自动添加时间, 修改或更新对象时, 不会更改时间
            create_time = models.DateTimeField(auto_now_add=True,  verbose_name="创建时间")
            
            # 更新时间: auto_now:凡是对对象进行操作(创建/添加/修改/更新),时间都会随之改变
            update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
        
            class Meta:
                # 说明是抽象模型类(抽象模型类不会创建表)
                abstract = True
 *  3： 定义登录使用的模型类：
    
        from django.db import models
        from meiduo_mall.utils.models import BaseModel
        
        # 定义QQ登录的模型类: 
        class OAuthQQUser(BaseModel):
            """QQ登录用户数据"""
        
            # user 是个外键, 关联对应的用户
            user = models.ForeignKey('users.User',  on_delete=models.CASCADE, verbose_name='用户')
            # qq 发布的用户身份id
            openid = models.CharField(max_length=64,  verbose_name='openid', db_index=True)
        
            class Meta:
                db_table = 'tb_oauth_qq'
 *  4: 安装QQ登录的安装包文件：pip install QQLoginTool -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  5：配置文件中配置QQ登录需要的参数：
    
        # QQ登录参数
        # 我们申请的 客户端id
        QQ_CLIENT_ID = '101474184'
        # 我们申请的 客户端秘钥
        QQ_CLIENT_SECRET = 'c6ce949e04e12ecc909ae6a8b09b637c'
        # 我们申请时添加的: 登录成功后回调的路径
        QQ_REDIRECT_URI = 'http://www.meiduo.site:8080/oauth_callback.html'
 *  6 : 第一个视图： 用户向我们后端请求QQ登录，后端需要向QQ发送请求QQ登录的URL,然后将这个URL返回给前端。
    
        from QQLoginTool.QQtool import OAuthQQ
        from django.conf import settings
        from django.http import JsonResponse
        from django.views import View
        
        
        class Get_QQ_Url_View(View):
            def get(self, request):
                #1: 获取请求后要跳转的页面
                next = request.GET.get("next")
                # 2: 创建QQ登录对象
                oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
                                client_secret=settings.QQ_CLIENT_SECRET,
                                redirect_uri=settings.QQ_REDIRECT_URI,
                                state=next)
                # 3: 调用对象获取登录的url
                login_url = oauth.get_qq_url()
                # 4: 将登录的地址返回给用户
                return JsonResponse({
              "code": 0, "errmsg": "ok", "login_url": login_url})
    
        """
        路由: 
        """
        from django.urls import re_path
        from oauth import views
        
        urlpatterns = [
            # 1: 获取QQ登录的url
            re_path(r"^qq/authorization/$", views.Get_QQ_Url_View.as_view()),
        
        ]
 *  7: 用户QQ认证后会返回给用户一个code，用户携带code来访问我们的后台，我们根据这个code，向QQ请求获取access\_tocken，拿到access\_tocken后我们再次请求QQ，获取这个用户的openid，根据这个openid检测用户是否存在，如果存在则，进行状态保持，如果不存在，则将openid加密后返回给用户。
    
        # QQ登录业务
        class Get_open_id_View(View):
            def get(self, request):
                # 1: 获取前端传来的code
                code = request.GET.get('code')
                if not code:
                    return JsonResponse({
              "code": 400, "errmsg": "没有携带code"})
                next = request.GET.get("next")
                # 2： 创建QQ登录对象
                oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
                                client_secret=settings.QQ_CLIENT_SECRET,
                                redirect_uri=settings.QQ_REDIRECT_URI,
                                state=next)
                # 3: 根据code获取access_tocken ,再根据access_tocken获取该用户的openid
                try:
                    access_tocken = oauth.get_access_tocken(code)
                    openid = oauth.get_open_id(access_tocken)
                except Exception as e:
                    return JsonResponse({
              "code": "400", "errmsg": "无法获取用户的eopenid"})
                else: # 程序不报错则执行的代码
                    # 判断这个用户是否绑定过后端的用户
                    try:
                        oauth_qq = OAuthQQUser.objects.get(openid=openid)
                    # 用户没有绑定美多商城用户,使用加密类加密用户的openid,返回给用户，
                    # 前端会让顾客填写信息，然后再带着这个openid返回
                    except Exception as e:
                        # 将openid进行加密然后返回，返回的是字符串类型
                        access_token = SecretOauth().dumps({
              'openid': openid})
                        return JsonResponse({
              'code': 300, 'errmsg': 'ok', 'access_token': access_token})
                    else: # 如果绑定了用户
                        user = oauth_qq.user
                        login(request, user) # 进行状态保持
                        response = JsonResponse({
              "code": '0', "errmsg": 'ok'})
                        response.set_cookie("username", user.username, max_age=3600 * 24 * 14) # 首页用户名展示
                        return response
    
        # 2: QQ登录认证:如果登录成功则进行状态保持，如果不成功则返回加密后的eopenid
            re_path(r'^oauth_callback/$', views.Get_open_id_View.as_view()),
 *  8： 用户再次填写用户的信息，如果根据手机号查询数据库中是否存在这个用户，如果存在则需要绑定原有用户的openid,如果不存在则创建新用户。
    
        def post(self, request):
                # 1.接收参数
                data_dict = json.loads(request.body.decode())
                mobile = data_dict.get('mobile')
                password = data_dict.get('password')
                sms_code_client = data_dict.get('sms_code')
                access_token = data_dict.get('access_token')
        
                # 2.校验参数
                # 判断参数是否齐全
                if not all([mobile, password, sms_code_client]):
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '缺少必传参数'})
        
                # 判断手机号是否合法
                if not re.match(r'^1[3-9]\d{9}$', mobile):
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '请输入正确的手机号码'})
        
                # 判断密码是否合格
                if not re.match(r'^[0-9A-Za-z]{8,20}$', password):
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '请输入8-20位的密码'})
        
                # 3.判断短信验证码是否一致
                # 创建 redis 链接对象:
                redis_conn = get_redis_connection('verify_code')
        
                # 从 redis 中获取 sms_code 值:
                sms_code_server = redis_conn.get('sms_%s' % mobile)
        
                # 判断获取出来的有没有:
                if sms_code_server is None:
                    # 如果没有, 直接返回:
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '验证码失效'})
                # 如果有, 则进行判断:
                if sms_code_client != sms_code_server.decode():
                    # 如果不匹配, 则直接返回:
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '输入的验证码有误'})
        
                # 调用我们自定义的函数, 检验传入的 access_token 是否正确:
                # 错误提示放在 sms_code_errmsg 位置
                openid = SecretOauth().loads(access_token).get('openid')
                print(openid)
                if not openid:
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '缺少openid'})
                # 4.保存注册数据
                try:
                    user = User.objects.get(mobile=mobile)
                except Exception as e:
                    # 用户不存在,新建用户
                    user = User.objects.create_user(username=mobile,
                                                    password=password,
                                                    mobile=mobile)
                else:
                    # 如果用户存在，检查用户密码
                    if not user.check_password(password):
                        return JsonResponse({
              'code': 400,
                                             'errmsg': '输入的密码不正确'})
                # 5.将用户绑定 openid
                try:
                    OAuthQQUser.objects.create(openid=openid,
                                               user=user)
                except DatabaseError:
                    return JsonResponse({
              'code': 400,
                                         'errmsg': '往数据库添加数据出错'})
                # 6.实现状态保持
                login(request, user)
        
                # 7.创建响应对象:
                response = JsonResponse({
              'code': 0,
                                         'errmsg': 'ok'})
        
                # 8.登录时用户名写入到 cookie，有效期14天
                response.set_cookie('username',
                                    user.username,
                                    max_age=3600 * 24 * 14)
        
                # 9.响应
                return response

## 8：itsdangerous加密模块对openid进行加密生成带有有效期的tocken ##

*  1： 安装加密模块： pip install itsdangerous -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  2: 学习地址： https://itsdangerous.readthedocs.io/en/1.1.x/
 *  3： 在工具类中创建对openid 进行加密和解密的模块：
    
        """
        openid进行加解密的业务逻辑：
        1： 首先初始化一个带有有效期的序列化对象，然后调用这个对象的dumps进行加密，使用这个对象的loads进行解密。
        2：注意解密可能失败，需要返回None
        """
    
        from django.conf import settings
        # 使用 TimedJSONWebSignatureSerializer 对象 可以设置有效期
        from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
        
        
        class SecretOauth(object):
            def __init__(self):
                # 根据django的密钥，创建一个序列化对象
                self.serializer = Serializer(secret_key= settings.SECRET_KEY, expires_in=24 * 15 * 60)
        
            def dumps(self, content_dict):
                # 1. 通过 dumps方法 加密数据
                result = self.serializer.dumps(content_dict)
                # 2. result是bytes类型转换成 str
                return result.decode()
        
            # 解密
            def loads(self, content_dict):
                try:
                    # 1. 通过 loads方法 解密数据
                    result = self.serializer.loads(content_dict)
                except Exception as e:
                    print(e)
                    # 解密失败返回None
                    return None
        
                # 2. 返回解密完毕数据
                return result

## 9： 用户基本信息展示与修改 ##

### 9.1: 用户基本信息展示： ###

*  视图：
    
        # 获取用户的基本信息
        class User_info_view(View):
            def get(self, request):
                user = request.user
                info_data = {
              
                    'username': user.username,
                    'mobile': user.mobile,
                    'email': user.email,
                    'email_active': user.email_active,
                }
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'info_data': info_data})
 *  路由：
    
        # 6: 返回用户的基本信息
            re_path(r"^info/$", views.User_info_view.as_view()),

### 9.2：修改密码： ###

*  修改密码的后端逻辑：
    
        """
        # 1：提取参数： 旧密码，新密码，二次密码
        # 2：校验参数： 存在性校验， 旧密码是否正确，新密码是否符合格式，两次密码是否一致。
        # 3：逻辑处理： 更新密码， 退出状态保持， 清除前端的cookie。
        # 4： 构建响应： 
        """
 *  视图：
    
        class User_password_reset_view(View):
            def put(self, request):
                # 1: 提取参数
                data = request.body.decode()
                data_dict = json.loads(data)
                old_password = data_dict.get('old_password')
                new_password = data_dict.get('new_password')
                new_password2 = data_dict.get('new_password2')
        
                # 2： 校验参数
                if not all([old_password, new_password, new_password2]):
                    return JsonResponse({
              "code": "400", 'errmsg': '参数缺失'})
                # 校验密码
                user = request.user
                if not user.check_password(old_password):
                    return JsonResponse({
              "code": '400', 'errmsg': '密码输入错误'})
                # 校验新密码的格式
                if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
                    return JsonResponse({
              'code': 400,'errmsg': '密码最少8位,最长20位'})
                # 校验两次密码是否一致
                if new_password != new_password2:
                    return JsonResponse({
              'code': 400, 'errmsg': '两次密码不一致'})
        
                # 3： 逻辑处理---修改密码
                try:
                    user.set_password(new_password)
                    user.save()
                except Exception as e:
                    return JsonResponse({
              "code": 500, 'errmsg': '修改密码失败，位置001'})
        
                # 退出状态保持
                logout(request)
                # 4: 构建响应返回
                response = JsonResponse({
              'code': 0, 'errmsg': 'ok'})
                response.delete_cookie('username')
        
                return response
 *  路由：
    
        # 7: 修改密码
            re_path(r"^password/$", views.User_password_reset_view.as_view()),

## 10：邮箱认证 ##

*  1： 在用户的模型类中增加email字段，并进行迁移建表：
    
        class User(AbstractUser):
            """自定义用户模型类"""
            mobile = models.CharField(max_length=11,
                                      unique=True,
                                      verbose_name='手机号')
            # 新增 email_active 字段
            # 用于记录邮箱是否激活, 默认为 False: 未激活
            email_active = models.BooleanField(default=False, verbose_name='邮箱验证状态')
            class Meta:
                db_table = 'tb_users'
                verbose_name = '用户'
                verbose_name_plural = verbose_name
            def __str__(self):
                return self.username
 *  2： 邮箱认证的后端逻辑分析：
    
        """
        1: 首先添加邮箱信息： 前端发来用户的邮箱，我们直接写入数据库就可以了。
        2：邮箱的认证：用户点击验证邮箱，我们后端使用异步任务向用户的邮箱发送信息，信息中携带用户名和手机号，进行加密后发送。
        3：用户点击后，访问我们的后台，我们检测解密后的用户名和手机号是否正确，来判断邮箱是否认证成功。
        """
    
        # 视图
        # 增加邮箱信息
        class Add_Email_View(View):
            def put(self, request):
                # 1: 提取参数
                data = request.body.decode()
                data_dict = json.loads(data)
                email = data_dict.get('email')
                # 2： 校验参数
                if not email:
                    return JsonResponse({
              'code': 400, 'errmsg': '参数缺失'})
                # 校验邮箱格式是否正确
                if not re.match(r'[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$', email):
                    return JsonResponse({
              'code': 400, 'errmsg': '邮箱的格式不正确'})
                # 3： 逻辑处理---增加email字段
                try:
                    user = request.user
                    user.email = email
                    user.save()
                except Exception as e:
                    return JsonResponse({
              'code': 400, 'errmsg': 'email字段保存失败'})
                # 4: 构建响应
                return JsonResponse({
              "code": 0, 'errmsg': 'ok'})
    
        # 路由：
         # 8: 邮箱认证---增加邮箱信息
            re_path(r"^emails/$", views.Add_Email_View.as_view()),
 *  3：增加我自己的163邮箱的配置信息：
    
        EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
        # 我们使用的 smtp服务器 地址
        EMAIL_HOST = 'smtp.163.com'
        # 端口号
        EMAIL_PORT = 25
        # 下面的内容是可变的, 随后台设置的不同而改变:
        # 发送邮件的邮箱
        EMAIL_HOST_USER = '17852032940@163.com'
        # 在邮箱中设置的客户端授权密码
        EMAIL_HOST_PASSWORD = 'PBEUPUHCNVFWDOOC'
        # 收件人看到的发件人
        EMAIL_FROM = '美多商城<17852032940@163.com>'
        EMAIL_VERIFY_URL = 'http://www.meiduo.site:8080/success_verify_email.html?token='
 *  4：在工具类中封装一个能够生成激活链接的函数： 传入request, 返回完整的激活路径。
    
        from django.conf import settings
        from meiduo_mall.utils.secret import SecretOauth
        
        # 生成激活链接
        def generate_verify_email_url(request):
            # 1： 使用itdangerous模块将用户的id和email，加密成一个tocken
            data_dict = {
              
                'user_id': request.user.id,
                'email': request.user.email
            }
            dumps_data = SecretOauth().dumps(data_dict)
        
            # 2.后端地址和tocken拼接在一起
            verify_url = settings.EMAIL_VERIFY_URL + dumps_data
        
            return verify_url
 *  5:异步任务发送：
    
    新建异步任务：在 celery\_tasks.email.tasks.py 中添加如下代码:
    
        """
        django已经集成了发送邮件的功能，from django.core.mail import send_mail， 可以发送邮件。
        """
        from django.core.mail import send_mail
        from django.conf import settings
        import logging
        logger = logging.getLogger('django')
        from celery_tasks.main import celery_app
        
        # 定义一个发送函数, 发送 email:
        @celery_app.task(name='send_verify_email')
        def send_verify_email(to_email, verify_url):
        
              # 标题
            subject = "美多商城邮箱验证"
              # 发送内容:
            html_message = '<p>尊敬的用户您好！</p>' \
                           '<p>感谢您使用美多商城。</p>' \
                           '<p>您的邮箱为：%s 。请点击此链接激活您的邮箱：</p>' \
                           '<p><a href="%s">%s<a></p>' % (to_email, verify_url, verify_url)
        
        
              # 进行发送
            result = send_mail(subject, # 邮箱标题
                       "",
                       settings.EMAIL_FROM, # 什么邮箱发送的
                       [to_email],# 发送给哪些邮箱
                       html_message=html_message)# 发送的邮箱信息是什么
        
            return result
    
    将这个task任务在main.py中注册：注意的问题是这个发送邮箱，需要加载django的配置文件，而celery是默认不会加载django的配置文件的，因此特殊指定加载。
    
        from celery import Celery
        import os
        
        if not os.getenv('DJANGO_SETTINGS_MODULE'):
            os.environ['DJANGO_SETTINGS_MODULE'] = 'meiduo_mall.settings.dev'
            
        # 1：创建celery对象
        celery_app = Celery("meiduo")
        # 2：加载配置文件
        celery_app.config_from_object('celery_tasks.config')
        # 3： 设置自动捕获tasks.py中的任务
        celery_app.autodiscover_tasks(['celery_tasks.sms','celery_tasks.email'])
    
    在邮件的视图中增加异步任务发送：
    
        from users.utils import generate_verify_email_url
                verify_url = generate_verify_email_url(request)
                from celery_tasks.email.tasks import send_verify_email
                # 发送验证链接:
                send_verify_email.delay(email, verify_url)
 *  6: 用户点击之后的修改邮箱的激活状态视图：
    
        # 9: 修改邮箱的激活状态
            re_path(r'^emails/verification/$', views.VerifyEmailView.as_view()),
    
        class VerifyEmailView(View):
            def put(self, request):
                # - 1.接收 token
                token = request.GET.get('token')
                if not token:
                    return JsonResponse({
              'code': 400, 'errmsg': 'token缺少'})
                # - 2.解密
                data_dict = SecretOauth().loads(token)
                # - 4.去数据库对比 user_id,email
                try:
                    user = User.objects.get(pk=data_dict.get('user_id'), email=data_dict.get('email'))
                except Exception as e:
                    print(e)
                    return JsonResponse({
              'code': 400, 'errmsg': '参数有误!'})
                # - 5.修改激活状态
                try:
                    user.email_active = True
                    user.save()
                except Exception as e:
                    return JsonResponse({
              'code': 0, 'errmsg': '激活失败!'})
                return JsonResponse({
              'code': 0, 'errmsg': '激活成功!'})

## 11：收货地址 ##

*  准备工作： 1： 创建一个子应用：areas
 *  2: 创建area模型类，并迁移建表
    
        from django.db import models
        
        class Area(models.Model):
            """
            行政区划
            """
            # 创建 name 字段, 用户保存名称
            name = models.CharField(max_length=20, verbose_name='名称')
            # 自关联字段 parent
            parent = models.ForeignKey('self', on_delete=models.SET_NULL, related_name='subs', null=True, blank=True, verbose_name='上级行政区划')
        
            class Meta:
                db_table = 'tb_areas'
        
            def __str__(self):
                return self.name
 *  3: 导入sql文件：
    
        # 1: 进入sql的脚本文件--->执行命令： mysql -uroot -pmysql 数据库名 < sql文件名
        # 例如: mysql -uroot -pmysql meiduo_mall < areas.sql

### 11.0: 省市区三级联动： ###

*  1： 获取省份的信息：
    
        """
        思路： 根据父类是空获取省份的列表，然后每个列表中的值，转换成字典再添加到列表中。
        """
        from django.http import JsonResponse
        from django.views import View
        
        from apps.areas.models import Area
        
        # 获取省份的信息
        class Get_provice_Area_View(View):
            def get(self, request):
                try:
                    provice_module_list = Area.objects.filter(parent__isnull=True)
                except Exception as e:
                    return JsonResponse({
              'code': '0', 'errmsg': '数据库省份信息错误'})
                provice_list = []
                for provice_module in provice_module_list:
                    provice_list.append({
              'id': provice_module.id,'name': provice_module.name})
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'province_list': provice_list})
    
        # 1: 获取省份的信息
            re_path(r"^areas/$", views.Get_provice_Area_View.as_view()),
 *  2： 获取市区的数据：
    
        """
        思路：首先前端传递过来一个父类的id,根据这个父类的id，可以查询到子类的信息列表对象，和父类的信息，然后将父类的信息以及子类的信息打包放在一起，然后按照要求返回。
        """
    
        # 获取市区的信息
        class GET_City_OR_Area_View(View):
            def get(self, request, pk):
                try:
                    parent_model = Area.objects.get(id =pk)
                    son_list = Area.objects.filter(parent = pk)
                except Exception as e:
                    return JsonResponse({
              "code": '400', 'errmsg': '查询数据库出错'})
        
                sub_list = []
                for son_modul in son_list:
                    sub_list.append({
              'id': son_modul.id, 'name': son_modul.name})
                sub_data = {
              
                    'id': parent_model.id,
                    'name': parent_model.name,
                    'subs': sub_list
                }
                return JsonResponse({
              "code": 0, 'errmsg': 'ok', 'sub_data': sub_data})
    
        # 2： 获取市区的信息
            re_path(r"^areas/(?P<pk>\d{1,9})/$", views.GET_City_OR_Area_View.as_view()),

### 11.1： 新增收货地址 ###

*  1: 新增收货地址的模型类：
    
        from django.db import models
        from django.contrib.auth.models import AbstractUser
        
        from meiduo_mall.utils.models import BaseModel
        
        
        class User(AbstractUser):
            """自定义用户模型类"""
            mobile = models.CharField(max_length=11,
                                      unique=True,
                                      verbose_name='手机号')
            # 新增 email_active 字段
            # 用于记录邮箱是否激活, 默认为 False: 未激活
            email_active = models.BooleanField(default=False, verbose_name='邮箱验证状态')
            default_address = models.ForeignKey('Address', related_name='users', null=True, blank=True,
                                                on_delete=models.SET_NULL, verbose_name='默认地址')
            class Meta:
                db_table = 'tb_users'
                verbose_name = '用户'
                verbose_name_plural = verbose_name
            def __str__(self):
                return self.username
            
            
        class Address(BaseModel):
            """
            用户地址
            """
            user = models.ForeignKey('users.User', on_delete=models.CASCADE, related_name='addresses', verbose_name='用户')
            province = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='province_addresses', verbose_name='省')
            city = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='city_addresses', verbose_name='市')
            district = models.ForeignKey('areas.Area', on_delete=models.PROTECT, related_name='district_addresses', verbose_name='区')
            title = models.CharField(max_length=20, verbose_name='地址名称')
            receiver = models.CharField(max_length=20, verbose_name='收货人')
            place = models.CharField(max_length=50, verbose_name='地址')
            mobile = models.CharField(max_length=11, verbose_name='手机')
            tel = models.CharField(max_length=20, null=True, blank=True, default='', verbose_name='固定电话')
            email = models.CharField(max_length=30, null=True, blank=True, default='', verbose_name='电子邮箱')
            is_deleted = models.BooleanField(default=False, verbose_name='逻辑删除')
        
            class Meta:
                db_table = 'tb_address'
                # 设置默认 已更新时间降序
                ordering = ['-update_time']
 *  2： 新增地址的逻辑：
    
        """
        1: 提取参数
        2: 校验参数
        3：数据处理：
        3.1：判断地址数量是否超过了20个，超过了20个则直接返回
        3.2：保存地址
        3.2：判断当前是否存在默认地址，没有默认地址则把这个设置成默认地址。
        """
    
        # 新增地址
        class CreateAddressView(View):
        
            def post(self, request):
                user = request.user
                # 1: 提取参数
                data = request.body.decode()
                import json
                data_dict = json.loads(data)
                receiver = data_dict.get('receiver')
                province_id = data_dict.get('province_id')
                city_id = data_dict.get('city_id')
                district_id = data_dict.get('district_id')
                place = data_dict.get('place')
                mobile = data_dict.get('mobile')
                tel = data_dict.get('tel')
                email = data_dict.get('email')
        
                # 2: 校验参数
                if not all([receiver, province_id, city_id, district_id, place, mobile]):
                    return JsonResponse({
              'code': 400,
                                              'errmsg': '缺少必传参数'})
                import re
                if not re.match(r'^1[3-9]\d{9}$', mobile):
                    return JsonResponse({
              'code': 400, 'errmsg': '参数mobile有误'})
        
                if tel:
                    if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
                        return JsonResponse({
              'code': 400, 'errmsg': '参数tel有误'})
                if email:
                    if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                        return JsonResponse({
              'code': 400, 'errmsg': '参数email有误'})
        
                # 3:业务处理
                # 3.1: 判断当前的地址是不是超过了２０个
                if Address.objects.filter(user= user, is_deleted=False).count() >= 20:
                    return JsonResponse({
              'code': 400, 'errmsg': '数量超出限制'})
                # 3.2: 保存地址信息
                try:
                    address = Address.objects.create( user=user,
                        title = receiver,
                        receiver = receiver,
                        province_id = province_id,
                        city_id = city_id,
                        district_id = district_id,
                        place = place,
                        mobile = mobile,
                        tel = tel,
                        email = email)
                except Exception as e:
                    return JsonResponse({
              "code": 500, 'errmsg': '新增地址失败'})
        
                # 3.2: 判断当前有没有默认地址，没有则设置为默认地址
                if not user.default_address:
                    try:
                        user.default_address = address
                        user.save()
                    except Exception as e:
                        return JsonResponse({
              "code": 500, "errmsg": '设置默认地址失败'})
        
                # 构建响应：－－－返回新增地址信息，让前端实现局部刷新
                address_dict = {
              **data_dict}
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'address':address_dict})
    
        # 3: 新增地址
            re_path(r"^addresses/create/$", views.CreateAddressView.as_view()),

### 11.2：展示收货地址 ###

*  视图代码：
    
        #　展示地址
        class ShowAddressView(View):
            
            def get(self, request):
                user = request.user
                # 获取所有的地址: 
                addresses = Address.objects.filter(user=request.user, is_deleted=False)
        
                # 创建空的列表
                address_dict_list = []
                # 遍历
                for address in addresses:
                    address_dict = {
              
                        "id": address.id,
                        "title": address.title,
                        "receiver": address.receiver,
                        "province": address.province.name,
                        "city": address.city.name,
                        "district": address.district.name,
                        "place": address.place,
                        "mobile": address.mobile,
                        "tel": address.tel,
                        "email": address.email
                    }
                    address_dict_list.append(address_dict)
        
                # 获取默认地址id
                default_id = user.default_address_id
        
                return JsonResponse(
                    {
              'code': 0, 'errmsg': 'ok', 'addresses': address_dict_list, 'default_address_id': default_id})
 *  路由：
    
        # 4: 展示地址
            re_path(r"^addresses/$", views.ShowAddressView.as_view()),

### 11.3：修改收货地址 ###

*  视图代码：
    
        # 修改收获地址
        class UpdateAddressView(View):
            
            def put(self, request, address_id):
                import json
                json_dict = json.loads(request.body.decode())
                receiver = json_dict.get('receiver')
                province_id = json_dict.get('province_id')
                city_id = json_dict.get('city_id')
                district_id = json_dict.get('district_id')
                place = json_dict.get('place')
                mobile = json_dict.get('mobile')
                tel = json_dict.get('tel')
                email = json_dict.get('email')
        
                # 校验参数
                if not all([receiver, province_id, city_id, district_id, place, mobile]):
                    return JsonResponse({
              'code': 400, 
                                              'errmsg': '缺少必传参数'})
        
                import re
                if not re.match(r'^1[3-9]\d{9}$', mobile):
                    return JsonResponse({
              'code': 400, 
                                              'errmsg': '参数mobile有误'})
        
                if tel:
                    if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
                        return JsonResponse({
              'code': 400, 
                                                  'errmsg': '参数tel有误'})
                if email:
                    if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                        return JsonResponse({
              'code': 400, 
                                                  'errmsg': '参数email有误'})
        
                # 判断地址是否存在,并更新地址信息
                try:
                    Address.objects.filter(id=address_id).update(
                        user = request.user,
                        title = receiver,
                        receiver = receiver,
                        province_id = province_id,
                        city_id = city_id,
                        district_id = district_id,
                        place = place,
                        mobile = mobile,
                        tel = tel,
                        email = email
                    )
                except Exception as e:
                    return JsonResponse({
              'code': 400, 
                                              'errmsg': '更新地址失败'})
        
                # 构造响应数据
                address = Address.objects.get(id=address_id)
                address_dict = {
              
                    "id": address.id,
                    "title": address.title,
                    "receiver": address.receiver,
                    "province": address.province.name,
                    "city": address.city.name,
                    "district": address.district.name,
                    "place": address.place,
                    "mobile": address.mobile,
                    "tel": address.tel,
                    "email": address.email
                }
        
                # 响应更新地址结果
                return JsonResponse({
              'code': 0, 
                                          'errmsg': '更新地址成功', 
                                          'address': address_dict})
 *  路由：
    
        # 5: 修改收获地址
            re_path(r"^addresses/(?P<address_id>\d+)/$", views.UpdateAddressView.as_view()),

### 11.4：删除收货地址 ###

注意删除的时候要看看是不是默认地址，如果是默认地址则，用户的默认地址要置空。

*  视图代码：
    
        def delete(self, request, address_id):
                """删除地址"""
                user = request.user
                try:
                    # 查询要删除的地址
                    address = Address.objects.get(id=address_id)
                    # 如果是默认地址，则默认地址要置空
                    if user.default_address.id == address.id:
                        try:
                            user.default_address = None
                            user.save()
                        except Exception as e:
                            return JsonResponse({
              'code': '500', 'errmsg': '默认地址无法删除'})
        
                    # 将地址逻辑删除设置为True
                    address.is_deleted = True
                    address.save()
                except Exception as e:
                    return JsonResponse({
              'code': 400,
                                              'errmsg': '删除地址失败'})
                # 响应删除地址结果
                return JsonResponse({
              'code': 0,
                                          'errmsg': '删除地址成功'})
 *  路由：
    
        # 5: 删除收获地址
            re_path(r"^addresses/(?P<address_id>\d+)/$", views.UpdateAddressView.as_view()),

### 11.5：设置默认的收货地址和修改地址标题 ###

*  设置默认的收货地址
    
        class DefaultAddressView(View):
            """设置默认地址"""
        
            def put(self, request, address_id):
                """设置默认地址"""
                try:
                    # 接收参数,查询地址
                    address = Address.objects.get(id=address_id)
        
                    # 设置地址为默认地址
                    request.user.default_address = address
                    request.user.save()
                except Exception as e:
                    return JsonResponse({
              'code': 400, 
                                              'errmsg': '设置默认地址失败'})
        
                # 响应设置默认地址结果
                return JsonResponse({
              'code': 0, 
                                          'errmsg': '设置默认地址成功'})
 *  默认收货地址路由：
    
        # 6: 设置默认的收获地址
            re_path(r"^addresses/(?P<address_id>\d+)/default/$", views.DefaultAddressView.as_view()),
 *  修改地址标题
    
        import json
        # 设置地址标题
        class UpdateTitleAddressView(View):
            """设置地址标题"""
        
            def put(self, request, address_id):
                """设置地址标题"""
                # 接收参数：地址标题
                json_dict = json.loads(request.body.decode())
                title = json_dict.get('title')
        
                try:
                    # 查询地址
                    address = Address.objects.get(id=address_id)
        
                    # 设置新的地址标题
                    address.title = title
                    address.save()
                except Exception as e:
                    return JsonResponse({
              'code': 400,
                                              'errmsg': '设置地址标题失败'})
        
                # 4.响应删除地址结果
                return JsonResponse({
              'code': 0,
                                          'errmsg': '设置地址标题成功'})
 *  路由：
    
        # 7: 设置地址标题
            re_path(r"^addresses/(?P<address_id>\d+)/title/$", views.UpdateTitleAddressView.as_view()),

## 12： 缓存策略 ##

*  `from django.core.cache import cache`缓存所在的包
 *  缓存存储数据： cache.set(‘key’, ‘value’, 有效期)
 *  读取缓存数据： cacae.get(‘key’)
 *  删除缓存数据： cache.delete(‘key’)
 *  通读策略的基本思想：
    
        """
        通读策略的基本思想：
        先读缓存，缓存命中则直接返回。
        缓存没有命中则，读取数据库，返回数据，并且回填缓存。
        """
 *  给查询省份信息增加缓存：
    
        # 增加缓存之后的获取省份的信息
        class Get_provice_Area_View(View):
            def get(self, request):
                from django.core.cache import cache
                # 1：先在缓存中读取数据
                provice_list = cache.get('provice_list')
                # 2: 缓存读不到，读取数据库
                if not provice_list:
        
                    try:
                        provice_module_list = Area.objects.filter(parent__isnull=True)
                    except Exception as e:
                        return JsonResponse({
              'code': '0', 'errmsg': '数据库省份信息错误'})
                    provice_list = []
                    for provice_module in provice_module_list:
                        provice_list.append({
              'id': provice_module.id, 'name': provice_module.name})
                    # 3: 回填缓存
                    cache.set('provice_list', provice_list, 3600)
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'province_list': provice_list})
 *  给市区信息增加缓存：
    
        # 增加缓存架构后：获取市区的信息
        class GET_City_OR_Area_View(View):
        
            def get(self, request, pk):
                try:
                    parent_model = Area.objects.get(id=pk)
                except Exception as e:
                    return JsonResponse({
              'code':0, 'errmsg': '数据库查询失败'})
        
                from django.core.cache import cache
                # 1: 查看缓存
                sub_list = cache.get('sub_list%s'% pk)
                # 2: 如果没有，查询数据库，然后回填缓存
                if not sub_list:
                    try:
                        son_list = Area.objects.filter(parent=pk)
                    except Exception as e:
                        return JsonResponse({
              "code": '400', 'errmsg': '查询数据库出错'})
        
                    sub_list = []
                    for son_modul in son_list:
                        sub_list.append({
              'id': son_modul.id, 'name': son_modul.name})
                    # 3: 回填缓存
                    cache.set('sub_list%s'%pk, sub_list, 3600)
        
                sub_data = {
              
                    'id': parent_model.id,
                    'name': parent_model.name,
                    'subs': sub_list
                }
        
                return JsonResponse({
              "code": 0, 'errmsg': 'ok', 'sub_data': sub_data})

## 13：商品模块—FastDFS文件存储系统 ##

*  FastDFS分佈式文件存储系统包括两部分：Tracker 和 Storage和Client。
 *  Tracker：负责监控Storage服务，提供下载/上传查找服务(决定了文件存储在哪个Storage和到哪个Storage服务器要图片)。
 *  Storage: 负责存储图片。
 *  client使用TCP/IP协议与Tracker和Storage进行交互。
 *  FASTDFS的文件索引：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Y2MaTKI-1609312736806)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201225140406717.png)\]
 *  FastDFS的上传流程：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vo51h6mA-1609312736807)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201225140011008.png)\]
 *  FASTDFS的下载流程：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NvTtDbHQ-1609312736808)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201225140034796.png)\]

## 14：Docker工具的使用： ##

*  启动docker： sudo service docker start
 *  重启docker: sudo service docker restart
 *  停止docker: sudo service docker stop

## 15：项目使用docker运行FASTDFS ##

*  1：将FASTDFS将压缩包恢复成镜像：sudo docker load -i fastdfs\_docker.tar
 *  2：删除原有的数据：
    
        sudo rm -rf /var/fdfs/*
        sudo mkdir /var/fdfs/tracker
        sudo mkdir /var/fdfs/storage
 *  3：删除原来的docker和tracker服务器：
    
        sudo docker container rm -f tracker
        sudo docker container rm -f storage
 *  4：开启Tracker和Storage服务器：
    
        sudo docker run -dit --name tracker --network=host -v /var/fdfs/tracker:/var/fdfs delron/fastdfs tracke
        
        sudo docker run -dti --name storage --network=host -e TRACKER_SERVER=192.168.203.153:22122 -v /var/fdfs/storage:/var/fdfs delron/fastdfs storage
 *  5：恢复数据
    
        cd <data.tar.gz所在目录>
        sudo tar -zxvf data.tar.gz -C /var/fdfs/storage
 *  6： 修改域名映射：
    
        vim /etc/hosts
        # 增加：192.168.203.153  image.meiduo.site

## 16：Django的文件存储后端 ##

*  1：问题：我们在处理ImageFiled类型的字段的时候，我们希望得到的是完整的图片链接。而django的ImageFiled类型字段有个Url属性，其值是该字段的链接。但是使用这个属性得到的结果是部分图片链接，而决定返回值的是Django的存储后端。
 *  2：django默认的存储后端：from django.core.files.storage import Storage
 *  3： 自定义文件存储后端：
    
        from django.core.files.storage import Storage
        from django.conf import settings
        
        
        # 1:自定义的文件存储后端要继承django默认的存储后端Storage
        class FastDFSStorage(Storage):
        
            def _open(self, name, mode="rb" ):
                # 打开django本地文件
                pass
        
            def _save(self, name, content, max_length=None):
                # 上传图片
                pass
        
            def url(self, name):
                # 返回"http://image.meiduo.site:8888/" + 图片在数据库中存储的地址
                return settings.FDFS_BASE_URL + name
    
        # 配置文件增加信息
        # 自定义文件存储类：
        # 指定自定义的Django文件存储类
        DEFAULT_FILE_STORAGE = 'meiduo_mall.utils.fastdfs.FastDFSStorage'
        # 定义fdfs服务url前缀
        FDFS_BASE_URL = 'http://image.meiduo.site:8888/'
 *  这样以后使用imagefiled.url得到的就是完整的图片链接了。

## 17：页面静态化理论 ##

*  1：网站首页(index.html)的访问频次是非常之高的，如果采用动态渲染的方式，每一次浏览器都需要请求动态服务器获取数据，然后渲染，那么咱们的动态服务器负载就会非常之高！
 *  2：对于向网站首页一样的，基本 不变，而且经常被访问的页面，我们可以提前渲染好页面，浏览器请求该页面的时候，直接返回该静态页面，无需动态请求。
 *  模型类的建立与数据的恢复：
    
        # 1：创建goods子应用（商品的数据）
        # 2： 增加模型类
        from django.db import models
        
        
        
        # Create your models here.
        from meiduo_mall.utils.models import BaseModel
        
        
        class GoodsCategory(BaseModel):
            """商品类别"""
            name = models.CharField(max_length=10, verbose_name='名称')
            parent = models.ForeignKey('self', related_name='subs', null=True, blank=True, on_delete=models.CASCADE, verbose_name='父类别')
        
            class Meta:
                db_table = 'tb_goods_category'
        
            def __str__(self):
                return self.name
        
        
        class GoodsChannelGroup(BaseModel):
            """商品频道组"""
            name = models.CharField(max_length=20, verbose_name='频道组名')
        
            class Meta:
                db_table = 'tb_channel_group'
        
            def __str__(self):
                return self.name
        
        
        class GoodsChannel(BaseModel):
            """商品频道"""
            group = models.ForeignKey(GoodsChannelGroup, on_delete=models.CASCADE, verbose_name='频道组名')
            category = models.ForeignKey(GoodsCategory, on_delete=models.CASCADE, verbose_name='顶级商品类别')
            url = models.CharField(max_length=50, verbose_name='频道页面链接')
            sequence = models.IntegerField(verbose_name='组内顺序')
        
            class Meta:
                db_table = 'tb_goods_channel'
        
            def __str__(self):
                return self.category.name
        
        
        class Brand(BaseModel):
            """品牌"""
            name = models.CharField(max_length=20, verbose_name='名称')
            logo = models.ImageField(verbose_name='Logo图片')
            first_letter = models.CharField(max_length=1, verbose_name='品牌首字母')
        
            class Meta:
                db_table = 'tb_brand'
        
            def __str__(self):
                return self.name
        
        
        class SPU(BaseModel):
            """商品SPU"""
            name = models.CharField(max_length=50, verbose_name='名称')
            brand = models.ForeignKey(Brand, on_delete=models.PROTECT, verbose_name='品牌')
            category1 = models.ForeignKey(GoodsCategory, on_delete=models.PROTECT, related_name='cat1_spu', verbose_name='一级类别')
            category2 = models.ForeignKey(GoodsCategory, on_delete=models.PROTECT, related_name='cat2_spu', verbose_name='二级类别')
            category3 = models.ForeignKey(GoodsCategory, on_delete=models.PROTECT, related_name='cat3_spu', verbose_name='三级类别')
            sales = models.IntegerField(default=0, verbose_name='销量')
            comments = models.IntegerField(default=0, verbose_name='评价数')
            desc_detail = models.TextField(default='', verbose_name='详细介绍')
            desc_pack = models.TextField(default='', verbose_name='包装信息')
            desc_service = models.TextField(default='', verbose_name='售后服务')
        
            class Meta:
                db_table = 'tb_spu'
        
            def __str__(self):
                return self.name
        
        
        class SKU(BaseModel):
            """商品SKU"""
            name = models.CharField(max_length=50, verbose_name='名称')
            caption = models.CharField(max_length=100, verbose_name='副标题')
            spu = models.ForeignKey(SPU, on_delete=models.CASCADE, verbose_name='商品')
            category = models.ForeignKey(GoodsCategory, on_delete=models.PROTECT, verbose_name='从属类别')
            price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name='单价')
            cost_price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name='进价')
            market_price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name='市场价')
            stock = models.IntegerField(default=0, verbose_name='库存')
            sales = models.IntegerField(default=0, verbose_name='销量')
            comments = models.IntegerField(default=0, verbose_name='评价数')
            is_launched = models.BooleanField(default=True, verbose_name='是否上架销售')
            default_image = models.ImageField(max_length=200, default='', null=True, blank=True, verbose_name='默认图片')
        
            class Meta:
                db_table = 'tb_sku'
        
            def __str__(self):
                return '%s: %s' % (self.id, self.name)
        
        
        class SKUImage(BaseModel):
            """SKU图片"""
            sku = models.ForeignKey(SKU, on_delete=models.CASCADE, verbose_name='sku')
            image = models.ImageField(verbose_name='图片')
        
            class Meta:
                db_table = 'tb_sku_image'
        
            def __str__(self):
                return '%s %s' % (self.sku.name, self.id)
        
        
        class SPUSpecification(BaseModel):
            """商品SPU规格"""
            spu = models.ForeignKey(SPU, on_delete=models.CASCADE, related_name='specs', verbose_name='商品SPU')
            name = models.CharField(max_length=20, verbose_name='规格名称')
        
            class Meta:
                db_table = 'tb_spu_specification'
        
            def __str__(self):
                return '%s: %s' % (self.spu.name, self.name)
        
        
        class SpecificationOption(BaseModel):
            """规格选项"""
            spec = models.ForeignKey(SPUSpecification, related_name='options', on_delete=models.CASCADE, verbose_name='规格')
            value = models.CharField(max_length=20, verbose_name='选项值')
        
            class Meta:
                db_table = 'tb_specification_option'
        
            def __str__(self):
                return '%s - %s' % (self.spec, self.value)
        
        
        class SKUSpecification(BaseModel):
            """SKU具体规格"""
            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 Meta:
                db_table = 'tb_sku_specification'
        
            def __str__(self):
                return '%s: %s - %s' % (self.sku, self.spec.name, self.option.value)
        # 3： 迁移建表
        python3 manage.py makemigrations
        python3 manage.py migrate
        
        # 4: SQL数据的录入
         mysql -uroot -pmysql -D meiduo_mall < goods.sql
    
        # 1：创建contants子应用（广告的数据）
        # 2：构建模型类
        from django.db import models
        
        from meiduo_mall.utils.models import BaseModel
        
        
        class ContentCategory(BaseModel):
            """广告内容类别"""
            name = models.CharField(max_length=50, verbose_name='名称')
            key = models.CharField(max_length=50, verbose_name='类别键名')
        
            class Meta:
                db_table = 'tb_content_category'
        
            def __str__(self):
                return self.name
        
        
        class Content(BaseModel):
            """广告内容"""
            category = models.ForeignKey(ContentCategory, on_delete=models.PROTECT, verbose_name='类别')
            title = models.CharField(max_length=100, verbose_name='标题')
            url = models.CharField(max_length=300, verbose_name='内容链接')
            image = models.ImageField(null=True, blank=True, verbose_name='图片')
            text = models.TextField(null=True, blank=True, verbose_name='内容')
            sequence = models.IntegerField(verbose_name='排序')
            status = models.BooleanField(default=True, verbose_name='是否展示')
        
            class Meta:
                db_table = 'tb_content'
        
            def __str__(self):
                return self.category.name + ': ' + self.title
        # 3： 导入SQL语句
        mysql -uroot -pmysql -D meiduo_mall < contents.sql

### 17.1： 首页静态化 ###

*  1： 删除front\_end\_pc中的首页index.html
 *  2：页面静态化的思路:
    
        """
        1: 根据我们的模本文件构造一个模板对象template =loader.get_template("index.html")
        2：构造动态数据，将动态数据填充到模板文件中。
        3：使用render函数渲染出页面。
        4：将页面写入到指定的文件中。
        """
    
        from django.template import loader
        import os
        from django.conf import settings
        from apps.contants.models import ContentCategory, Content
        from apps.goods.models import GoodsChannel, GoodsCategory
        def generate_static_index_html():
        
            # 获取分类频道数据和首页的内容数据
            categories = get_categories()
            contents = get_contents()
        
            # 1:构建首页模板文件对象
            template = loader.get_template("index.html")
        
            # 2:构造动态数据
            content = {
              
                "categories": categories,
                "contents": contents,
            }
        
            # 3:渲染完整的页面数据
            page = template.render(content)
        
            # 4:写入静态web服务器
            with open("/home/python/Desktop/meimei_project/front_end_pc/front_end_pc/index.html", "w") as f:
                f.write(page)
 *  3： 考虑分类数据如何构建？
    
        def get_categories():
            # 模版参数categories是首页分类频道,里面包含所有频道数据以及商品分类的信息
            # 1：首先分析前段页面最外层是个字典数据，所以先定义一个字典，以后向里面增加数据。
            categories = {
              }
        
            # 获取首页所有的分类频道数据
            # 获取商品频道集
            # 先按频道组分类，如果频道相同，就按照sequence(商品分类所在频道组的位置)分类
            channels = GoodsChannel.objects.order_by(
                'group_id',
                'sequence'
            )
            
            # 遍历所有的商品频道，构建以组号作为key的键值对  channels ：商品频道集 channel：某个商品频道
            for channel in channels:
                # channel: GoodsChannel对象
                # 如果该商品频道的频道组没有在（最外层）频道字典中
                if channel.group_id not in categories:
                    # 将这个频道的频道组id，作为频道字典的一个键
                    categories[channel.group_id] = {
              
                        'channels': [],  # 当前分组中的分类频道(一级分类)
                        'sub_cats': []  # 二级分类
                    }
                # (1)、填充当前组中的一级分类
                # 某个商品频道的category属性获的商品分类对象：例如 ： 手机 数码等
                cat1 = channel.category
                # 给一级分类追加数据
                categories[channel.group_id]['channels'].append({
              
                    'id': cat1.id,
                    'name': cat1.name,
                    'url': channel.url
                })
        
        
        
                # (2)、填充当前组中的二级分类
                # 商品分类表对象获得二级商品分类（父亲是一级商品分类的）
                cat2s = GoodsCategory.objects.filter(parent=cat1)
                for cat2 in cat2s:
                    # cat2：二级分类对象
        
                    cat3_list = []  # 每一次遍历到一个二级分类对象的时候，初始化一个空列表，用来构建三级分类
                    cat3s = GoodsCategory.objects.filter(parent=cat2)
                    # (3)、填充当前组中的三级分类
                    for cat3 in cat3s:
                        # cat3；三级分类对象
                        cat3_list.append({
              
                            'id': cat3.id,
                            'name': cat3.name
                        })
                    
                    #将三级分类列表加入二级分类中
                    categories[channel.group_id]['sub_cats'].append({
              
                        'id': cat2.id,
                        'name': cat2.name,
                        'sub_cats': cat3_list  # 三级分类
                    })
        
            return categories
 *  4: 首页数据如何构建？
    
        def get_contents():
            contents = {
              }
            # 所有广告分类
            # 用广告分类表对象获取所有的广告分类
            content_cats = ContentCategory.objects.all()
            # 遍历所有的广告分类，获取其中一个广告分类。
            for content_cat in content_cats:
                # content_cat: 每一个分类如：轮播图
                # 当前广告分类关联的所有广告加入列表中
                # contents['index_lbt'] = [<美图M8s>, <黑色星期五>...]
                # 广告分类表中有个key字段，这个字段表示是哪个广告分类。
                contents[content_cat.key] = Content.objects.filter(
                    #广告表中的category_id等于广告分类表的id
                    category=content_cat,
                    status=True  # 正在展示的广告
                ).order_by('sequence')
        
            return contents
 *  5：渲染模板文件绝对路径修改成相对路径。
    
        # 在配置文件中，将模板文件地址设置成全局变量
        # 静态文件路径：
        # 基础路径向上两层：就是我们的meimei_project路径，然后拼接上front_end_pc就是我们静态文件路径。
        STATIC_FILE_PATH = os.path.join(
            os.path.dirname(os.path.dirname(BASE_DIR)),
            'front_end_pc'
        )
    
        file_path = os.path.join(settings.STATIC_FILE_PATH, 'index.html')
            with open(file_path, "w") as f:
                f.write(page)

### 17.2：使用定时任务执行页面静态化 ###

*  1： 安装定时模块：pip install django-crontab -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  2：注册应用：
    
        'django_crontab',
 *  3：在配置文件中增加定时任务的规则：
    
        # 定时任务规则：
        # 五颗星分别代表 分钟，小时，日，月，年
        # 前面加斜杠表示每分钟，每小时，每个月，每年
        # 'apps.contents.crons.generate_static_index_html'表示定时任务函数的路径
        # '>> ' + os.path.join(BASE_DIR, 'logs/crontab.log')，表示重定向到指定的日志文件。
        
        CRONJOBS = [
            # 每1分钟生成一次首页静态文件
            ('*/1 * * * *', 'apps.contants.crons.generate_static_index_html', '>> ' + os.path.join(BASE_DIR, 'logs/crontab.log'))
            # 每月的23日12点1分0秒执行一次
            # ('1 12 23 * *', 'apps.contants.crons.generate_static_index_html', '>> ' + os.path.join(BASE_DIR, 'logs/crontab.log'))
        ]
 *  4：使用命令增加，查看，删除任务
    
        # 1: 添加任务： python3 manager.py crontab add
        # 2: 查看当前活跃的任务： python3 manager.py crontab show
        # 3: 删除任务: python3 manage.py crontab remove

### 17.3：商品详情页静态化 ###

*  1: 在app/goods中创建工具类，生成utils.py文件。
 *  2：将detial文件拷贝到模板文件夹下。
 *  3：在项目外层目录，创建一个文件夹scripts,在目录里面新建regenerate\_detail\_html.py文件。
    
        # 如果我想要在终端以脚本的方式启动这个文件，而这个脚本需要django的环境
        # 1:所以需要提前加载django环境,但是有个问题，'meiduo_mall.settings.dev'这个目录默认在这个文件下找meiduo_mall
        # 所以需要指定基准目录
        #  以当前目录为基准找到外层目录：
        import os, sys
        from django.template import loader
        
        # /Users/weiwei/Desktop/meiduo_mall_sz39/meiduo_mall/
        BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        sys.path.insert(0, BASE_DIR)
        
        # 由于当前脚本依赖django环境，所以需要提前加载django环境
        # 1、设置django环境变量指定配置文件路径
        os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'meiduo_mall.settings.dev')
        # 2、手动加载Django环境
        import django
        django.setup()
        
        from django.conf import settings
        from apps.goods.utils import *
        
        def generate_static_sku_detail_html(sku_id):
            
            categories = get_categories()
            goods, sku, specs = get_goods_and_spec(sku_id)
            
            # 1:使用get_template函数获取模板页面对象
            template = loader.get_template('detail.html')
            # 2：构造动态数据
            context = {
              
                'categories': categories,
                'goods': goods,  # 当前sku从属的spu
                'specs': specs,  # 规格和选项信息
                'sku': sku  # 当前sku商品对象
            }
            # 3：渲染页面
            page = template.render(context)
            
            # 4：将页面重新写入静态文件
            # 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)
        
        
        if __name__ == '__main__':
            from apps.goods.models import SKU
            # 在SKU表中查看所有没有过期的sku
            skus = SKU.objects.filter(is_launched=True)
            # 循环遍历skus
            for sku in skus:
                generate_static_sku_detail_html(sku.id)
 *  4: 在scripts下执行：
    
        python3 regenerate_detail_html.py

## 18： 脚本执行方式： ##

*  1: 给这个脚本增加可执行权限：chmod +x ./regenerate\_detail\_html.py
 *  2:在脚本开头指定解释器：\#！/user/bin/env python3

## 19：商品列表页 ##

### 19.1：商品列表页思路： ###

*  1： 商品列表页路由：
    
        urlpatterns = [
            # 1: 商品的列表页
            re_path(r'^list/(?P<category_id>\d+)/skus/$', views.List_Views.as_view()),
        ]
 *  2：思路：
    
        """
        1: 请求参数：:路径传参（三级分类的id）, page, page_size, ordering,查询字符串传参。
        2：逻辑处理：:根据前端要求返回数据。
        2.1: 根据我们的三级商品分类id，数据库查询出一个结果集skus.
        2.2: 根据skus和page_size构造一个分页器对象。
        2.3：根据page获取分页器中的当前页的数据对象。
        2.4: 遍历数据对象，根据前端要求的格式返回数据。
        """
 *  3： 视图代码：
    
        from django.core.paginator import Paginator
        from django.http import JsonResponse
        from django.views import View
        
        from apps.goods.models import SKU
        from apps.goods.utils import get_breadcrumb
        
        
        class List_Views(View):
        
            def get(self, request, category_id):
        
                # 1: 提取参数
                page = request.GET.get('page')
                page_size = request.GET.get('page_size')
                ordering = request.GET.get('ordering')
                # 2: 校验参数－－－无需
                # 3: 逻辑处理---分页返回数据
                # 3.1: 根据我们的三级商品分类id，数据库查询出一个结果集skus.
                try:
                    skus = SKU.objects.filter(category_id= category_id, is_launched=True).order_by(ordering)
                except Exception as e:
                    return JsonResponse({
              "code": '400', 'errmsg': '数据库查询失败，没有这个数据'})
                # 3.2: 根据skus和page_size构造一个分页器对象。
                paginator = Paginator(skus, page_size)
                # 3.3：根据page获取分页器中的当前页的数据对象
                try:
                    cur_page = paginator.page(page)
                except Exception as e:
                    return JsonResponse({
              "code": 500, 'errmsg': '分页失败'})
                # 3.4: 遍历数据对象，根据前端要求的格式返回数据。
                sku_list = []
                for sku in cur_page:
                    # sku:当前页中的每一个SKU对象
                    sku_list.append({
              
                        'id': sku.id,
                        'default_image_url': sku.default_image.url, # 面包屑导航
                        'name': sku.name,
                        'price': sku.price
                    })
        
                # 4、构建响应
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'breadcrumb': get_breadcrumb(category_id),
                    'list': sku_list,
                    'count': paginator.num_pages  # 总页数
                })

### 19.2： 分页： ###

*  from django.core.paginator import Paginator， 帮我们封装了，可以直接使用。
 *  paginator = Paginator(skus, page\_size)， 生成分页器对象
 *  cur\_page = paginator.page(page)， 获取当前页。

### 19.3: 列表页热销排行： ###

*  视图代码：
 *      # 热销商品排行
        class HotGoodsView(View):
            # 传入商品种类id
            def get(self,request,category_id):
        
                #根据商品id查询所有的sku商品
                skus = SKU.objects.filter(
                    category_id = category_id,
                    # 还在有效期内
                    is_launched = True
                ).order_by('-sales')[0:3]# 根据销量降序排列，然后选取前三个
        
                hot_skus = [{
              'id': sku.id, 'default_image_url': sku.default_image.url, 'name': sku.name, 'price': sku.price} for sku in skus]
        
                return JsonResponse({
              
                    "code": 0,
                    "errmsg": 'ok',
                    "hot_skus": hot_skus
                })
 *  路由：
    
        # 2: 热销商品排行
            re_path(r'^hot/(?P<category_id>\d+)/$', views.HotGoodsView.as_view()),

## 20：ES搜索引擎的使用（Elasticsearch）7.6.2（版本） ##

### 20.1：ES搜索引擎的原理？（全文检索） ###

*  1： Elasticsearch是面向文档的，可以看做是个数据库。
 *  2：数据库—>索引， 表---->type(慢慢会被弃用), 行---->documents(文档)， 字段---->fields
 *  3：ES一旦搭建就是一个集群，一个节点就是一个ES进程， 结点可以有很多索引默认的，如果你创建索引，那么索引有5个分片构成，每个主分片会有一个副本（赋值分片）
 *  4： 在ES中，索引被划分成多个分片，每个分片底层都是一个Lucene索引，所以ES索引其实是Lucene索引的一个集成。
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JFjhqPik-1609312736809)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201226104438527.png)\]
 *  4： 倒排索引？
    
        """
        倒排索引的原理就是根据每个内容，划分每个单词，建立一个单词和文档id一一对应的表，查询的时候查看匹配权重，高的就排在前面。
        """
 *  5： ES的流程： 建立索引（创建一个库）---->定义文档类型（数据库的字段类型）---->填充文档内容
 *  6：IK分词器：中文分词需要安装： elasticsearch-analysis-ik
    
        """
        案例：任善文 分成： 任， 善， 文， 任善， 善文， 任文， 任善文
        # 1： 下载ik分词器：
        # 2： IK提供两种分词算法： ik_smart（最小切分）, 一种是ik_max_word（最细切分粒度）。
        """

### 20.2：使用Docker快速搭建ES搜索引擎： ###

*  1： 安装ES搜索服务端：sudo docker image pull delron/elasticsearch-ik:2.4.6-1.0
 *  或者解压：sudo docker load -i elasticsearch-ik-2.4.6\_docker.tar
    
        """
        # 1: 将安装包导入到桌面：
        # 2: 在安装包的位置执行：docker image load -i  elasticsearch-ik-2.4.6_docker.tar，将es运行成容器。
        # 3：解压ES配置文件到/home目录sudo tar -zxvf elasticsearch-2.4.6.tar.gz -C /home
        
        # 4： 修改配置文件中的id和端口：
        sudo vim /home/elasticsearch-2.4.6/config/elasticsearch.yml
        network.host: 192.168.203.153
        # 5: 启动容器：
        sudo docker run -dti --name=elasticsearch --network=host -v /home/elasticsearch-2.4.6/config:/usr/elasticsearch/config delron/elasticsearch-ik:2.4.6-1.0
        """
 *  2: 安装ES客户端：pip install elasticsearch==2.4.1 -i https://pypi.tuna.tsinghua.edu.cn/simple

## 21：Haystack扩展建立索引 ##

*  1：Haystack 可以在不修改代码的情况下使用不同的搜索后端。
 *  2：安装Haystack ：pip install django-haystack -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  3： 注册Haystack应用：
    
        INSTALLED_APPS = [
            'haystack', 
        ]
 *  4： 在配置文件中配置Haystack与ES的连接信息：
    
        # 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'
 *  4： 使用haystack把模型类的数据写入es搜索引擎中。
    
        """
        1：新建apps/goods/search_indexes.py，指定对那个模型类建立索引文件。注意这个名字是固定的，不能改变。
        """
        """
        注意：该模块名search_indexes.py名称固定
        """
        
        from haystack import indexes
        
        from apps.goods.models import SKU
        
        # 明确：被检索的数据是SKU模型类数据，针对SKU模型类构建"索引模型类"
        # 固定的索引类名：<Django模型类> + Index
        class SKUIndex(indexes.SearchIndex, indexes.Indexable):
            # text是复合字段(该字段同时存储的是sku.name,sku.caption,sku.id)，该字段就是将来用于搜索的固定字段
            # use_template=True表示，将来使用模版来指定该字段关联的Django模型类对象的属性
            text = indexes.CharField(document=True, use_template=True)
        
            def get_model(self):
                # 返回的Django模型类，就是被检索的模型类
                return SKU
        
            def index_queryset(self, using=None):
                # 返回SKU的查询集，将来就是把这个查询集里面所有的sku商品数据写入es中等待被检索
                return self.get_model().objects.filter(is_launched=True)
    
        # 2: 定义模板文件，到底写入ES哪些SKU中的字段
        # 新建如下目录结构（注意是固定的不能改变）
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qNY9MURK-1609312736811)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201226130657727.png)\]
    
        """
        执行命令构建反向索引：
        在外层目录下执行： 
        python3 manager.py rebuild_index
        """
 *  5: 使用Haystack提供的搜索视图函数完成搜索：
    
        # 可以在 dev.py 中添加如下代码, 用于决定每页显示数据条数:
        HAYSTACK_SEARCH_RESULTS_PER_PAGE = 5
    
        urlpatterns = [
            # sku搜索,映射的时候无需调用as_view
            re_path(r'^search/$', views.MySearchView()),
        ]
    
        """
        ES搜索引擎的业务逻辑：
        注意Haystack中提供了SearchView的接口，我们只需要继承这个接口，重写create_response方法构建自己的返回格式就可以了。
        """
    
        # sku商品搜索接口
        from haystack.views import SearchView
        class MySearchView(SearchView):
            # 当前继承的SearchView是HayStack工具提供的
            # 该视图已经实现了一个self.get视图函数，来完成搜索
        
            def create_response(self):
                # 重写目的：构建一个json数据返回
        
                # 核心方法self.get_context() --> 和ES通信获取检索的结果
                context = self.get_context()
        
                ret_list = []
                # 遍历出每一个搜索的结果：SearchResult对象
                for result in context['page'].object_list:
                    # result: SearchResult对象
                    sku = result.object
                    ret_list.append({
              
                        'id': sku.id,
                        'name': sku.name,
                        'price': sku.price,
                        'default_image_url': sku.default_image.url,
                        'searchkey': context['query'],
                        'page_size': context['paginator'].per_page,
                        'count': context['paginator'].count
                    })
        
                # JsonResponse默认只能传入字典
                # 如果传入的是列表，需要把safe设置为False
                return JsonResponse(ret_list, safe=False)

## 22：浏览历史记录模块 ##

*  1: 思路：
    
        """
        当用户访问详情页面的时候，我们要把商品的信息存储起来，作为登录用户的浏览记录。
        如果用户没有登录，则不记录用户的浏览记录。
        1： 作为存储历史记录，所以使用redis就可以了。
        2： redis应该什么类型存储SKU商品的id? 
        答：我们应该使用列表存储。列表我们可以插入到头部，表示最新的记录。
        2.1： 首先插入之前，我们要判断该字段是否有重复的数据，如果有则删除。
        2.2：然后插入到头部
        2.3：插入完成之后，对列表截断，只保留5条数据。
        """
 *  2: 配置redis数据库新增库，用来专门存储历史记录
    
        "history": {
              
                    "BACKEND": "django_redis.cache.RedisCache",
                    "LOCATION": "redis://192.168.203.153:6379/3",
                    "OPTIONS": {
              
                        "CLIENT_CLASS": "django_redis.client.DefaultClient",
                    }
                },

### 22.1： 增加浏览历史记录： ###

*  视图：
    
        # 用户浏览历史记录
        class UserBrowseHistory(View):
            def post(self, request):
                user = request.user
                # 1、提取参数
                # 2、校验参数
                data = json.loads(request.body.decode())
                sku_id = data.get('sku_id')
                if not sku_id:
                    return JsonResponse({
              
                        'code': 400,
                        'errmsg': '缺少参数'
                    }, status=400)
        
                try:
                    SKU.objects.get(pk=sku_id, is_launched=True)
                except SKU.DoesNotExist as e:
                    return JsonResponse({
              
                        'code': 404,
                        'errmsg': '商品已下架/不存在'
                    }, status=404)
        
                # 3、数据/业务处理 —— 把访问的sku的id写入redis表示记录一条浏览历史
                if user.id:
                    # 3.1、获取"history"缓存配置的redis链接
                    conn = get_redis_connection('history')
                    p = conn.pipeline()
                    # 3.2、历史记录写入缓存
                    # 3.2.1、去重
                    p.lrem(
                        'history_%d' % user.id,
                        0,  # 删除所有指定成员
                        sku_id
                    )
                    # 3.2.2、插入列表头
                    p.lpush(
                        'history_%d' % user.id,
                        sku_id
                    )
                    # 3.2.3、截断保留5个记录
                    p.ltrim(
                        'history_%d' % user.id,
                        0,
                        4
                    )
                    p.execute()  # 批量执行redis指令
        
                # 4、构建响应
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok'
                })
 *  2： 路由：
    
        # 10: 添加用户的浏览历史记录
            re_path(r'^browse_histories/$', views.UserBrowseHistory.as_view()),

### 22.2: 查看用户浏览历史记录： ###

*      # 查看历史
            def get(self, request):
        
                user = request.user
                # 1、提取参数
                # 2、校验参数
                # 3、数据/业务处理 —— 用户浏览的sku商品信息返回(读redis获取最近浏览的历史sku.id, 读mysql获取sku详细信息)
                # 3.1、读redis获取浏览历史
                conn = get_redis_connection('history')
                # sku_ids = [b'6', b'3', b'4', b'14', b'15']
                sku_ids = conn.lrange(
                    'history_%d' % user.id,
                    0,
                    -1
                )
        
                skus = []  # 用于记录返回sku商品的详细信息
                # 3.2、读mysql获取详细信息
                for sku_id in sku_ids:
                    # sku_id = b'6'
                    sku = SKU.objects.get(pk=int(sku_id))
                    skus.append({
              
                        'id': sku.id,
                        'name': sku.name,
                        'default_image_url': sku.default_image.url,
                        'price': sku.price
                    })
        
                # 4、构建响应
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'skus': skus
                })
 *      # 10: 添加用户的浏览历史记录
           re_path(r'^browse_histories/$', views.UserBrowseHistory.as_view()),

## 23：pickle和base64模块进行编解码 ##

*  将一个python对象编码成字节格式，或者将字节格式解码成python对象。
 *  base64将三个字节，编码成一个可视化的字符，或者可视化字符解码成。

案例测试：

# 1：编码测试：字典数据--->字节数据 ---> 字节类型字符串数据--->encode变成前端可以看见的字符串。
        cart_bytes = pickle.dumps(cookie_cart)
        print("cart_bytes:", cart_bytes)
        # : cart_bytes: b'\x80\x03}q\x00(K\x01}q\x01(X\x05\x00\x00\x00countq\x02K\x05X\x08\x00\x00\x00selectedq\x03\x88uK\x02}q\x04(h\x02K\x0fh\x03\x89uu.'
        cart_string = base64.b64encode(cart_bytes)
        print("cart_string:", cart_string)
        # :cart_string: b'gAN9cQAoSwF9cQEoWAUAAABjb3VudHECSwVYCAAAAHNlbGVjdGVkcQOIdUsCfXEEKGgCSw9oA4l1dS4='
    
    
        # 2:解码测试   变成前端可以看见的字符串decode--->字节类型字符串数据--->字节类型--->字典数据
    
        cart_bytes = base64.b64decode(cart_string)
        print("使用base64解码后的数据：", cart_bytes)
        # 使用base64解码后的数据： b'\x80\x03}q\x00(K\x01}q\x01(X\x05\x00\x00\x00countq\x02K\x05X\x08\x00\x00\x00selectedq\x03\x88uK\x02}q\x04(h\x02K\x0fh\x03\x89uu.'
    
        cart_dict = pickle.loads(cart_bytes)
        print("使用loads解码后的数据：", cart_dict)
        #使用loads解码后的数据： {1: {'count': 5, 'selected': True}, 2: {'count': 15, 'selected': False}}

## 24：购物车模块 ##

*  登录状态下，购物车存储的思路：
    
        """
        1：购物车数据量小，结构简单，更新频繁，所以我们选择内存型数据库Redis进行存储。
        2：需要存储：sku的id，对于sku的详细信息，我们redis不存储，根据id查询MYSQL数据库就能获取详细信息。还需要存储sku的数量，以及商品的勾选状态。
        
        3：因此我们可以这样设计：
        对于sku商品的id和数量，我们可以使用redis中的哈希来存储，原因是哈希可以存储一键多值。
        对于勾选状态，，我们采用的是redis集合来存储，在集合内的表示选中的，没有在集合内的，表示没有选中的。
        
        4： 存储逻辑：当购物车商品已经存在了，则对数量进行增加，如果不存在则新增数据，初始数量设置成1.
        """
 *  未登录状态下，购物车的存储思路：
    
        """
        1: 使用json字符串存储在cookie中。
        2: cookie的加解密，使用pickle与Base64
        """
 *  1：创建子应用专门处理购物车数据：
 *  2：配置购物车专用的redis缓存:
    
        "carts": {
              
            	"BACKEND": "django_redis.cache.RedisCache",
            	"LOCATION": "redis://192.168.203.153:6379/4",
            	"OPTIONS": {
              
            	    "CLIENT_CLASS": "django_redis.client.DefaultClient",
            	}
        	},
 *  3： 封装cookie的编解码工具类：
    
        import pickle, base64
        
        class CookieSecret(object):
        
            # 自定义编码方法
            @staticmethod
            def dump(data):
                """请传入一个字典数据，返回一个字符串数据"""
                # 将字典数据编码字节类型数据
                data_bytes = pickle.dumps(data)
        
                #将字节类型数据编码成字节类型的字符串数据
                data_string = base64.b64encode(data_bytes)
        
                return data_string.decode()
        
        
            @staticmethod
            def loads(data):
                """请传入一个字节类型字符串的数据，返回一个字典类型数据"""
                # 将可视化字节类型数据转换成真正的字节类型数据
                data_bytes = base64.b64decode(data)
        
                # 将字节类型数据转换成对象类型
                data_dict = pickle.loads(data_bytes)
        
                return data_dict

### 24.1： 添加购物车 ###

*  添加购物车模块的思路：
    
        """
        1: 提取参数： body（sku, count, selected）
        2: 校验参数：存在性校验+查看商品是否下架了+ count传递的是不是整数 + selected是不是整数
        3: 如果该用户登陆了，连接redis数据库，使用hincrby来增加商品的数据，hincrby这个函数，如果存在就让数量递增，如果不存在则新建。对于是否选中，如果selected是True，则向集合这个sku的id，如果是False，则在集合中删除数据。
        
        4: 如果该用户没有登录：
        在请求中获取cookie,然后解码cookie， 拿到字典数据。
        判断字典中是否存在了该sku的id，如果存在了，则直接修改count的数量，如果没有，则新建。
        还要考虑如果购物车不存在的情况： 如果不存在也要新建。
        最后要把这个数据进行加密后返回给前端。
        """
 *  视图代码：
    
        import json
        
        from django.http import JsonResponse
        from django.views import View
        from django_redis import get_redis_connection
        from apps.goods.models import SKU
        from meiduo_mall.utils.cookiesecret import CookieSecret
        
        
        class CartsView(View):
        
            # 添加购物车
            def post(self, request):
        
                # 1：提取参数
                user = request.user
                data = json.loads(request.body.decode())
                sku_id = data.get('sku_id')
                count = data.get('count')
                selected = data.get('selected', True)
        
                # 2:校验参数
                # 存在性校验
                if not all ([sku_id, count]):
                    return JsonResponse({
              
                        "code": "400",
                        "errmsg": "参数缺失"
                    })
                # 查看商品的id是否存在，以及是否下架了
                try:
                    SKU.objects.get(pk=sku_id, is_launched=True)
                except SKU.DoesNotExist as e:
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "商品不存在或者已经下架了"
                    })
                # 判断传入的count是不是整数
                try:
                    count = int(count)
                except Exception as e:
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "您输入的不是整数"
                    })
                # 判断selected 是不是整数
                if not isinstance(selected,bool):
                    return JsonResponse({
              
                        "code" : 400,
                        "errmsg": "selectde不是bool类型"
                    })
        
        # 3：数据处理---判断用户是否登陆，划分两部分
                # 如果用户登陆了，使用哈希存储商品的id和商品的数量，使用集合存储选中的商品的id
                # 如果用户没有登陆，
        		# 用户登陆了
                if user.is_authenticated:
                    # 连接数据库
                    conn = get_redis_connection("carts")
                    # 用哈希存储商品的id和数量,使用carts_用户id，作为哈希的键
                    conn.hincrby(
                        'carts_%d' % user.id,
                        sku_id,
                        count,
                    )
                    # 选中信息在redis中用一个集合来存，在集合内部的就是选中的，没有在集合里的就是没有选中的。
                    #集合的键就是select_用户id  ,内部值是sku的id
                    if selected:
                        conn.sadd(
                            'selected_%d' % user.id,
                            sku_id,
                        )
                    else:
                        conn.srem(
                            'selected_%d' % user.id,
                            sku_id,
                        )
                    return JsonResponse({
              
                        'code': 0,
                        'errmsg': "ok",
                    })
                else:
                    # 1：获取请求中的cookie
                    cookie_carts = request.COOKIES.get('carts')
                    # 两种情况，购物车数据存在或者不存在。
                    if cookie_carts:
                        # 2:解码cookie中的数据,先解码成字节类型，然后传入自定义的 CookieSecret中解码成字典类型
                        cookie_byte = cookie_carts.encode()
                        cart_dict = CookieSecret.loads(cookie_byte)
        
                        # 3:判断判断新增的sku商品是否在原来的cookie 购物车中，如果存在则进行数量的累加，如果不存在则新建
                        if sku_id in cart_dict:
                            cart_dict[sku_id]['count'] += count
                            cart_dict[sku_id]['selected'] = selected
        
                        else:
                            # 新增这个商品
                            cart_dict[sku_id] = {
              
                                'count': count,
                                'selected': selected
                            }
        
                    # 如果购物车不存在，重新构建商品字典集合
                    else:
                        cart_dict =  {
              }
                        cart_dict[sku_id] = {
              
                            'count': count,
                            'selected': selected,
                        }
        
                    # 对购物车的字典数据进行编码，然后构建响应返回
                    cookie_str = CookieSecret.dump(cart_dict)
        
                    response = JsonResponse({
              
                        'code': 0,
                        'errmsg': 'ok',
                    })
        
                    response.set_cookie(
                        'carts',
                        cookie_str
                    )
        
                    return response
 *  路由：
    
        from django.urls import re_path
        
        from apps.carts import views
        
        urlpatterns = [
            # 1:购物车的正删改查
            re_path(r'^carts/$', views.CartsView.as_view()),
        ]

### 24.2： 展示购物车 ###

*  视图代码：
    
        # 展示购物车接口：
            def get(self, request):
        
                user = request.user
        
                #不管是从redis数据库中读数据还是从cookie中读取数据，都组织成字典格式
                # cart_dict = {1: {"count": 5, "selected": True}}
                cart_dict = {
              }
        
                # 如果用户登陆了
                if user.is_authenticated:
                    # 1： 获取连接对象
                    conn = get_redis_connection('carts')
                    # 2:读取该用户的商品id和商品数量（哈希的键是carts_用户的id）
                    skus_dict = conn.hgetall('carts_%s'% user.id)
                    #{b"1": b"5", b"2": b"15"}读取的数据类似这样。编号为1的商品有5本
        
                    # 3：读取该用户商品哪些是被选中的。
                    skus_selected = conn.smembers("selected_%s"% user.id)
        
                    # 4:构造字典格式：
                    for k, v in skus_dict.items():
                        cart_dict[int(k)] = {
              
                            'count': int(v),
                            'selected': k in skus_selected
                        }
                # 如果用户没有登陆
                else:
                    cookie_carts = request.COOKIES.get('carts')
        
                    if cookie_carts:
                        cart_dict = CookieSecret.loads(cookie_carts.encode())
        
        
                cart_skus = []
        
                # 根据字典数据查找sku商品的详细信息
                for k, v in cart_dict.items():
                    # 拿到商品的具体对象 # k: 1; v: {"count": 5, "selected": True}
                    sku = SKU.objects.get(pk=k)
        
                    cart_skus.append(
                        {
              
                            'id': sku.id,# 商品的id
                            'name': sku.name,# 商品名
                            'default_image_url': sku.default_image.url,# 拿到图片的路径
                            'price': sku.price,# 拿到商品的价格
                            'count':v['count'],# 拿到商品的数量
                            'selected': v['selected'] # 拿到商品是否被选中的属性
                        }
                    )
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'cart_skus': cart_skus
                })

### 24.3： 修改购物车 ###

*  视图代码
    
        # 修改购物车
            def put(self, request):
                user = request.user
        
                # 1、提取参数
                data = json.loads(request.body.decode())
                sku_id = data.get('sku_id')
                count = data.get('count')
                selected = data.get('selected', True)
        
                # 2、校验参数
                if not all([sku_id, count]):
                    return JsonResponse({
              'code': 400, 'errmsg': '缺少参数'}, status=400)
        
                try:
                    SKU.objects.get(pk=sku_id, is_launched=True)
                except SKU.DoesNotExist as e:
                    print(e)
                    return JsonResponse({
              'code': 404, 'errmsg': 'sku不存在'}, status=404)
        
                try:
                    # count = int("5")
                    count = int(count)
                except Exception as e:
                    print(e)
                    return JsonResponse({
              'code': 404, 'errmsg': 'count参数有误'}, status=400)
        
                if not isinstance(selected, bool):
                    return JsonResponse({
              'code': 404, 'errmsg': 'selected参数有误'}, status=400)
        
                # 3、业务/数据处理 —— 修改redis or 修改cookie
                if user.is_authenticated:
                    # 登陆状态,修改redis购物车数据
                    conn = get_redis_connection('carts')
                    # 商品数据：hash对象{16: 4}; 勾选状态：集合[16]
                    conn.hset(
                        'carts_%d' % user.id,
                        sku_id,
                        count
                    )
                    if selected:
                        conn.sadd('selected_%d'%user.id, sku_id)
                    else:
                        conn.srem('selected_%d' % user.id, sku_id)
        
                    return JsonResponse({
              
                        'code': 0,
                        'errmsg': 'ok',
                        'cart_sku': {
              
                            'sku_id': sku_id,
                            'count': count,
                            'selected': selected
                        }
                    })
        
                else:
                    # 未登陆，修改cookie购物车数据
                    # 购物车字典格式{1: {"count": 5, "selected": True}}
                    cart_dict = None # 改变是用来记录cookie中解码出来的购物车字典数据，如果cookie没有购物车该变量设置为空字典
                    cookie_carts = request.COOKIES.get('carts') # "ASjibgrehgbBHBHlbgre=" or None
                    if cookie_carts:
                        cart_dict = CookieSecret.loads(cookie_carts.encode()) # 解码得出字典数据
                    else:
                        cart_dict = {
              }
        
                    # 修改购物车字典数据，重新写入cookie返回
                    cart_dict[sku_id] = {
              
                        'count': count,
                        'selected': selected
                    }
        
                    # 编码购物车数据设置到cookie中
                    cookie_carts = CookieSecret.dumps(cart_dict)
                    response = JsonResponse({
              
                        'code': 0,
                        'errmsg': 'ok',
                        'cart_sku': {
              
                            'sku_id': sku_id,
                            'count': count,
                            'selected': selected
                        }
                    })
                    response.set_cookie(
                        'carts',
                        cookie_carts
                    )
                    return response

### 24.4：删除购物车 ###

*  删除购物车
    
        # 删除购物车
            def delete(self, request):
                user = request.user
                data = json.loads(request.body.decode())
                sku_id = data.get('sku_id')
        
                if user.is_authenticated:
                    # 1、登陆，删除redis购物车
                    # 商品和数量哈希对象：carts_1 : {1: 5}
                    # 选中状态集合对象：[1]
                    conn = get_redis_connection('carts')
                    conn.hdel('carts_%d'%user.id, sku_id)
                    conn.srem('selected_%d'%user.id, sku_id)
                    return JsonResponse({
              'code': 0, 'errmsg': 'ok'})
                else:
                    # 2、未登陆，删除cookie购物车
                    # 2.1、先读cookie购物车数据
                    cookie_carts = request.COOKIES.get('carts')
                    if cookie_carts:
                        # 2.2、解码出购物车字典格式数据
                        cart_dict = CookieSecret.loads(cookie_carts.encode())
                    else:
                        cart_dict = {
              }
        
                    # 2.3、在字典数据中删除当前sku商品
                    # del cart_dict[sku_id] or cart_dict.pop(sku_id) # 如果key不存在会报异常KeyError
                    try:
                        cart_dict.pop(sku_id)
                    except KeyError as e:
                        print(e)
                        return JsonResponse({
              'code': 400, 'errmsg': '删除错误！'})
        
                    # 2.4、重新编码写入cookie
                    cookie_carts = CookieSecret.dumps(cart_dict)
                    response = JsonResponse({
              'code': 0, 'errmsg': 'ok！'})
                    response.set_cookie(
                        'carts',
                        cookie_carts
                    )
                    return response

### 24.5：全选购物车 ###

*  视图
    
        # 全选购物车接口的实现
        class CartsSelectAllView(View):
            def put(self, request):
        
                user = request.user
                # 1:提取参数
                data = json.loads(request.body.decode())
                selected = data.get("selected", True)
                # 2：校验参数---校验selected是不是bool类型
                if not isinstance(selected, bool):
                    return JsonResponse({
              
                        "code": 400,
                        "errmsg": "数据类型错误"
                    }, status=400)
        
                # 3: 业务处理---将所有的sku商品的selected修改为True
                # 思路：如果用户登陆了---1：获取购物车中的所有商品---2：将所有的商品的selected修改为True或者False
                if user.is_authenticated:
                    # 1:获取redis数据库连接
                    conn = get_redis_connection('carts')
        
                    # 2:根据用户id获取所有的购物车中的sku商品(字节集合)
                    cart_dict = conn.hgetall("carts_%d" % user.id)
        
                    # 3:获取购物车集合所有的键（sku_id）
                    sku_ids = cart_dict.keys()
        
                    # 4:如果选中则根据键集合，全部修改选中集合。
                    if selected:
                        conn.sadd("selected_%d"% user.id, *sku_ids)
                    else:
                        conn.srem("selected_%d"% user.id, *sku_ids)
        
                    # 4:构建响应返回
                    return JsonResponse({
              
                        "code": 0,
                        "errmsg": "ok"
                    })
        
                # 用户没有登陆---修改cookie中的购物车
                else:
                    # 思路：1：提取cookie中的购物车数据，并解密成字典。---2：修改购物车的选中字段---3：重新构建响应返回
        
                    # 1：提取购物车数据,并解密
                    cookie_carts = request.COOKIES.get("carts")
                    if cookie_carts:
                        cart_dict = CookieSecret.loads(cookie_carts)
                    else:
                        cart_dict = {
              }
        
                    # 2:修改购物车选中字段
        
                    # 获取所有的键
                    sku_ids = cart_dict.keys()
                    for sku_id in sku_ids:
                        # 如果传入的是false 则全部写入false
                        cart_dict[sku_id]['selected'] = selected
        
                    # 3: 重新编码cookie数据
                    cookie_carts = CookieSecret.dumps(cart_dict)
                    response = JsonResponse({
              
                        'code': 0,
                        'errmsg': "ok"
                    })
                    response.set_cookie(
                        'carts',
                        cookie_carts
                    )
                    return response
 *  视图：
    
        from django.urls import re_path
        
        from apps.carts import views
        
        urlpatterns = [
            # 1:购物车的正删改查
            re_path(r'^carts/$', views.CartsView.as_view()),
            # 2: 全选购物车与取消全选购物车
            re_path(r'^carts/selection/$', views.CartsSelectAllView.as_view()),
        ]

### 24.6：合并购物车： ###

*  合并购物车的业务逻辑：
    
        """
        1.合并方向：cookie购物车数据合并到Redis购物车数据中。
        2.合并数据：购物车商品数据和勾选状态。
        3.合并方案：
        3.1 Redis数据库中的购物车数据保留。
        3.2 如果cookie中的购物车数据在Redis数据库中已存在，将cookie购物车数据覆盖Redis购物车数据。
        3.3 如果cookie中的购物车数据在Redis数据库中不存在，将cookie购物车数据新增到Redis。
        """
 *  新建一个工具类：合并购物车，让用户登录的时候进行调用。
    
        """
        合并购物车接口
        """
        from meiduo_mall.utils.cookiesecret import CookieSecret
        from django_redis import get_redis_connection
        
        def merge_cart_cookie_to_redis(request, response):
            """
            功能：合并购物车
            :param request: 请求对象 -----> 获取cookie购物车数据
            :param response: 响应对象 -----> 删除cookie购物车
            :return: 响应对象
            """
            user = request.user
        
            # 1、获取cookie购物车数据
            cookie_carts = request.COOKIES.get('carts')
            if cookie_carts:
                cart_dict = CookieSecret.loads(cookie_carts)
            else:
                cart_dict = {
              }
        
            # cart_dict = {1: {"count": 5, "selected": True}, 2: {"count": 15, "selected": True}}
        
            # 2、操作redis把cookie数据合并
            conn = get_redis_connection('carts')
            # redis购物车哈希 = {b'1': b'10'}
            # conn.hset() --> 给redis哈希对象一次设置一个键值对
            # conn.hmset() --> 给redis哈希对象一次设置多个键值对
            cart_redis_dict = {
              } #  {1: 5, 2: 15}
            sku_ids = cart_dict.keys()
            for sku_id in sku_ids:
                # cart_redis_dict = {1: 5}
                cart_redis_dict[sku_id] = cart_dict[sku_id]['count']
                # 把对应的sku商品的状态设置到redis集合中
                if cart_dict[sku_id]['selected']:
                    conn.sadd('selected_%d'%user.id, sku_id) # 如果当前sku在cookie中是选中的，则加入redis集合
            if cart_redis_dict:
                # 存在则覆盖原值， 不存在则新增
                conn.hmset('carts_%d'%user.id, cart_redis_dict)
        
        
            # 3、操作响应对象删除cookie购物车返回
            response.delete_cookie('carts')
            return response
 *  平凡登录时，合并购物车：
    
        class LoginView(View):
        
            def post(self, request):
                # ......
                # 合并购物车
                return merge_cart_cookie_to_redis(request, response)
 *  注册的时候合并购物车：
    
        # 注意注册的时候请求对象是没有这个user的，即request.user= None
        # 用户注册
        class RegisterView(View):
        
            def post(self, request):
                # 1、......
                # 合并购物车
                requset.user = user
                return merge_cart_cookie_to_redis(request, response)
 *  QQ登录的时候合并购物车：
    
        class QQUserView(View):
        
            # qq登陆接口3：把用户的美多账号 和 用户的qq身份(openid) 进行绑定
            def post(self, request):
                # 1、......
                # 合并购物车
                request.user = user
                return merge_cart_cookie_to_redis(request, response)
        
            # qq登陆接口2：验证code获取openid
            def get(self, request):
                # ......
                # 代码走到此处，表明，美多后台已经成功获取了用户的openid
                # 3.4、判读用户的"美多商城账号"和"openid"是否绑定
                try:
                    oauth_user = OAuthQQUser.objects.get(openid=openid)
                except OAuthQQUser.DoesNotExist as e:
                    # 3.4.1、用户没有绑定qq
                    # ......
                else:
                    # 3.4.2、用户绑定过qq
                    # ......
                    # 合并购物车
                    request.user = oauth_user.user
                    return merge_cart_cookie_to_redis(request, response)

### 24.8：购物车页面的展示： ###

*  视图：
    
        # 简单购物车展示
        class CartsSimpleView(View):
        
            def get(self, request):
        
                user = request.user
        
                # 约定一个购物车字典
                cart_dict = {
              } # {1: {"count": 5, "selected": True}}
        
                if user.is_authenticated:
                    conn = get_redis_connection('carts')
                    # {b'1': b'5'}
                    redis_cart_dict = conn.hgetall('carts_%d'%user.id)
                    # [b'1']
                    redis_selected = conn.smembers('selected_%d'%user.id)
        
                    for k,v in redis_cart_dict.items():
                        # k: b'1'；  v: b'5'
                        cart_dict[int(k)] = {
              
                            'count': int(v),
                            'selected': k in redis_selected
                        }
                else:
                    cookie_carts = request.COOKIES.get('carts')
                    if cookie_carts:
                        cart_dict = CookieSecret.loads(cookie_carts)
        
        
                sku_ids = cart_dict.keys()
                cart_skus = []
                for sku_id in sku_ids:
                    if cart_dict[sku_id]['selected']:
                        sku = SKU.objects.get(pk=sku_id)
                        cart_skus.append({
              
                            'id': sku.id,
                            'name': sku.name,
                            'count': cart_dict[sku_id]['count'],
                            'default_image_url': sku.default_image.url
                        })
        
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'cart_skus': cart_skus
                })
 *  路由：
    
        urlpatterns = [
            # 1:购物车的正删改查
            re_path(r'^carts/$', views.CartsView.as_view()),
            # 2: 全选购物车与取消全选购物车
            re_path(r'^carts/selection/$', views.CartsSelectAllView.as_view()),
            # 3: 合并购物车
            re_path(r'^carts/simple/$', views.CartsSimpleView.as_view()),
        ]
 *  修改前端代码：index.html
    
        <div class="guest_cart fr">
                    <a href="#" class="cart_name fl">我的购物车</a>
                    <div class="goods_count fl" id="show_count">[[cart_total_count]]</div>
        
                    <ul class="cart_goods_show">
                        <li v-for="sku in carts">
                            <img :src="sku.default_image_url" alt="商品图片">
                            <h4>[[sku.name]]</h4>
                            <div>[[sku.count]]</div>
                        </li>
                    </ul>
                </div>

## 25： 订单模块 ##

*  新建子应用orders
 *  创建模型类：
    
        from meiduo_mall.utils.models import BaseModel
        from django.db import models
        
        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('users.User', on_delete=models.PROTECT, verbose_name="下单用户")
            address = models.ForeignKey('users.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
        
            def __str__(self):
                return self.order_id
        
        
        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('goods.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
        
            def __str__(self):
                return self.sku.name
 *  迁移建表

### 25.1： 新建保存订单： ###

*  1： 业务逻辑：
    
        我们存在两个表，订单表（主表:订单id, 总数量，用户id, 总价，运费，支付方式）+ 订单商品表（从：商品的单价，数量，id）
        """
        1: 提取参数： 地址的id,以及支付方式。
        2： 校验参数： 必要性校验 + 地址是否存在 + 支付方式是否支持。
        3： 业务处理： 
        3.1： 读取购物车的数据
        3.2: 生成订单的唯一标志： 时间戳 + 用户id的后六位
        
        """
 *  2：对于钱，我们使用Decimal类型而不能使用浮点数。
    
        1: Decimal传入字符串
        2：Decimal强转不会存在误差
        """
        d1 = Decimal('2.3')
        d2 = Decimal('3')
        d1 * d2
        >> Decimal('6.9')
        float(Decimal('6.9'))
        6.9
        """
 *  3： 视图：
    
        # 保存/新建订单
        import json
        from datetime import timezone
        from meiduo_mall.utils.views import LoginRequiredJSONMixin
        from decimal import Decimal
        from django.http import JsonResponse
        from django.views import View
        from django_redis import get_redis_connection
        
        from goods.models import SKU
        from orders.models import OrderInfo, OrderGoods
        from users.models import Address
        
        
        class OrderCommitView(LoginRequiredJSONMixin, View):
        
            def post(self, request):
        
                data = json.loads(request.body.decode())
                address_id = data.get('address_id')
                pay_method = data.get('pay_method')
        
                if not all([address_id, pay_method]):
                    return JsonResponse({
              'code': 400, 'errmsg': '缺少参数'})
        
                try:
                    Address.objects.get(pk=address_id)
                except Address.DoesNotExist as e:
                    return JsonResponse({
              'code': 400, 'errmsg': '地址不存在'})
        
                if pay_method not in [OrderInfo.PAY_METHODS_ENUM['CASH'], OrderInfo.PAY_METHODS_ENUM['ALIPAY']]:
                    return JsonResponse({
              'code': 400, 'errmsg': '付款方式不支持'})
        
                # 0、把购物车中的sku商品数据读取出来
                cart_dict = {
              } # {1: {"count": 5, "selected": True}}
                conn = get_redis_connection('carts')
                # {b"1": b"5"}
                redis_skus = conn.hgetall('carts_%d'%request.user.id)
                # [b'1']
                redis_selected = conn.smembers('selected_%d'%request.user.id)
                for sku_id,count in redis_skus.items():
                    if sku_id in redis_selected:
                        cart_dict[int(sku_id)] = {
              
                            'count': int(count),
                            'selected': sku_id in redis_selected
                        }
        
                # 数据/业务处理
                # 1、新建订单表数据OrderInfo(主)
                # 20200912111256000001 ----> 约定订单的id的格式：时间戳 + 用户id(固定长度)
                # 加上时间戳可以保证这个订单的id唯一性
                order_id = timezone.localtime().strftime('%Y%m%d%H%M%S') + '%06d'%request.user.id
                freight = Decimal('10.5')
                order = OrderInfo.objects.create(
                    order_id=order_id,
                    user=request.user,
                    address_id=address_id,
                    total_count=0, # 初始化
                    total_amount=0, # 初始化
                    freight=freight,
                    pay_method=pay_method
                )
        
                # 2、插入订单商品表数据OrderGoods(从) --> 具体的sku商品就是购物车中选中的商品
                sku_ids = cart_dict.keys()
                for sku_id in sku_ids:
                    # 购物车中的sku商品
                    sku = SKU.objects.get(pk=sku_id)
                    # 中间表OrderGoods表中插入一条数据，表示新建的订单中的sku商品
                    OrderGoods.objects.create(
                        order=order,
                        sku=sku,
                        count=cart_dict[sku_id]['count'],
                        price=sku.price,
                    )
        
                    order.total_count += cart_dict[sku_id]['count']
                    order.total_amount += cart_dict[sku_id]['count'] * sku.price
        
                order.total_amount += freight
                order.save()
        
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'order_id': order_id
                })
 *  4： 路由：
    
        # 保存订单
            re_path(r'^orders/commit/$', views.OrderCommitView.as_view()),

### 25.2： 乐观锁下单： ###

*  1: 修改数据库的隔离级别：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yIcIkbtq-1609312736813)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201230102752592.png)\]
 *  2： 乐观锁的执行流程：
    
        # 1: 读取旧的数据
        # 2: 基于旧的数据计算新的数据
        # 3: 在旧的数据基础上，先查询一下，看看数据库数据是否存在，然后更新新数据。
 *  3：代码展示:
    
        class OrderCommitView(LoginRequiredJSONMixin, View):
        
            def post(self, request):
        
                data = json.loads(request.body.decode())
                address_id = data.get('address_id')
                pay_method = data.get('pay_method')
        
                if not all([address_id, pay_method]):
                    return JsonResponse({
              'code': 400, 'errmsg': '缺少参数'})
        
                try:
                    Address.objects.get(pk=address_id)
                except Address.DoesNotExist as e:
                    return JsonResponse({
              'code': 400, 'errmsg': '地址不存在'})
        
                if pay_method not in [OrderInfo.PAY_METHODS_ENUM['CASH'], OrderInfo.PAY_METHODS_ENUM['ALIPAY']]:
                    return JsonResponse({
              'code': 400, 'errmsg': '付款方式不支持'})
        
        
                # 0、把购物车中的sku商品数据读取出来
                cart_dict = {
              } # {1: {"count": 5, "selected": True}}
                conn = get_redis_connection('carts')
                # {b"1": b"5"}
                redis_skus = conn.hgetall('carts_%d'%request.user.id)
                # [b'1']
                redis_selected = conn.smembers('selected_%d'%request.user.id)
                for sku_id,count in redis_skus.items():
                    if sku_id in redis_selected:
                        cart_dict[int(sku_id)] = {
              
                            'count': int(count),
                            'selected': sku_id in redis_selected
                        }
                sku_ids = cart_dict.keys()
        
                # 数据/业务处理
                # 1、新建订单表数据OrderInfo(主)
                # 20200912111256000001 ----> 约定订单的id的格式：时间戳 + 用户id(固定长度)
                # 加上时间戳可以保证这个订单的id唯一性
                order_id = timezone.localtime().strftime('%Y%m%d%H%M%S') + '%06d'%request.user.id
                freight = Decimal('10.5')
        
        
                with transaction.atomic():
                    # 设置一个事务保存点
                    save_id = transaction.savepoint()
        
                    order = OrderInfo.objects.create(
                        order_id=order_id,
                        user=request.user,
                        address_id=address_id,
                        total_count=0, # 初始化
                        total_amount=0, # 初始化
                        freight=freight,
                        pay_method=pay_method
                    )
        
                    # 2、插入订单商品表数据OrderGoods(从) --> 具体的sku商品就是购物车中选中的商品
                    for sku_id in sku_ids:
        
                        # 乐观锁处理机制
                        while True:
                            # 购物车中的sku商品
                            sku = SKU.objects.get(pk=sku_id)
                            # (1)、读旧的库存和销量
                            old_stock = sku.stock
                            old_sales = sku.sales
        
                            # TODO: 判断库存和销量
                            # 用户下单量
                            count = cart_dict[sku_id]['count']
                            if count > old_stock:
                                # 库存不足, 回滚事务
                                transaction.savepoint_rollback(save_id)
                                return JsonResponse({
              'code': 400, 'errmsg': '库存不足'}, status=400)
        
                            # 修改销量和库存数据
                            # sku.stock -= count
                            # sku.sales += count
                            # sku.save()
        
                            # (2)、基于旧库存和销量计算新值
                            new_stock = old_stock - count
                            new_sales = old_sales + count
                            # (3)、在旧库存和销量基础上，查询后修改
                            ret = SKU.objects.filter(
                                pk=sku.id,
                                stock=old_stock,
                                sales=old_sales
                            ).update(stock=new_stock, sales=new_sales)
                            # 如果update函数返回值为0，说明filter过滤结果为空，说明根据旧数据找不到原有的sku
                            # 说明有别的事务介入
                            if ret:
                                # 如果ret不为0，说明正确更新
                                break
        
                        # 中间表OrderGoods表中插入一条数据，表示新建的订单中的sku商品
                        OrderGoods.objects.create(
                            order=order,
                            sku=sku,
                            count=cart_dict[sku_id]['count'],
                            price=sku.price,
                        )
        
                        order.total_count += cart_dict[sku_id]['count']
                        order.total_amount += cart_dict[sku_id]['count'] * sku.price
        
                    order.total_amount += freight
                    order.save()
        
                    # 提交保存点（删除保存点）
                    transaction.savepoint_commit(save_id)
        
        
                # 下单结束删除购物车
                conn.hdel('carts_%d'%request.user.id, *sku_ids)
                conn.srem('selected_%d'%request.user.id, *sku_ids)
        
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'order_id': order_id
                })

### 25.3： 结算页面： ###

*  视图：
    
        class OrderSettlementView(LoginRequiredJSONMixin, View):
        
            def get(self, request):
                user = request.user
        
                # 返回用户可选地址
                addresses = []
                add_queryset = Address.objects.filter(
                    user=user,
                    is_deleted=False
                )
                for address in add_queryset:
                    addresses.append({
              
                        'id': address.id,
                        'province': address.province.name,
                        'city': address.city.name,
                        'district': address.district.name,
                        'place': address.place,
                        'mobile': address.mobile,
                        'receiver': address.receiver
                    })
        
                # 返回选中的购物车数据
                skus = []
        
                conn = get_redis_connection('carts')
                # redis_skus = {b'1': b'5'}
                redis_skus = conn.hgetall('carts_%d'%user.id)
                # redis_selected = [b'1']
                redis_selected = conn.smembers('selected_%d'%user.id)
        
                for sku_id,count in redis_skus.items():
                    # sku_id: b'1'; count: b'5'
                    if sku_id in redis_selected:
                        sku = SKU.objects.get(pk=int(sku_id))
                        skus.append({
              
                            'id': sku.id,
                            'name': sku.name,
                            'default_image_url': sku.default_image.url,
                            'count': int(count),
                            'price': sku.price
                        })
        
                return JsonResponse({
              
                    'code': 0,
                    'errmsg': 'ok',
                    'context': {
              
                        'addresses': addresses,
                        'skus': skus,
                        'freight': Decimal('10.5') # 计算的时候不会丢失精度
                    }
                })
 *  路由：
    
        from django.urls import re_path
        from . import views
        
        urlpatterns = [
            re_path(r'^orders/settlement/$', views.OrderSettlementView.as_view()),
        ]

## 26： 支付宝支付接口： ##

*  支付宝开放者平台：https://open.alipay.com/platform/home.htm
 *  支付宝沙箱环境： https://openhome.alipay.com/platform/appDaily.htm?tab=account
 *  沙箱参数：
    
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6vpOul7N-1609312736814)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201230144010712.png)\]
 *  \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vocgLNqQ-1609312736815)(C:\\Users\\11737\\AppData\\Roaming\\Typora\\typora-user-images\\image-20201230144126361.png)\]
 *  支付宝支付的逻辑：
    
        """
        1: 首先，用户请求扫码支付，我们的后端，使用sdk和支付宝对接，获取扫码的链接，然后将链接返回给用户。
        2: 用户跟支付宝之间进行交互。
        3: 支付成功后用户被重定向到我们的后端，我们需要校验yoghurt支付是否成功，如果校验成功，保存支付订单信息（订单和支付订单进行绑定）。
        """

### 26.1： 对称加密和非对称加密： ###

*  我们的后台与支付宝的后台通信必须是加密通信的。
 *  对称加密： 加密和解密使用同一个秘钥。
 *  非对称加密： 两个秘钥–（公钥，私钥）。
    
     *  通信的时候使用私钥加密数据，使用公钥解密私钥。
     *  通讯双方都生成自己的公钥和私钥。
     *  场景：
        
            """
            1：AB生成公私密钥
            A生成A的公钥和私钥
            B生成B的公钥和私钥
            
            2：AB双方互换公钥
            A把A的公钥交给B
            B把B的公钥交给A
            
            3: 通讯
            A使用A的私钥加密数据给B端， B使用A的公钥解密数据。
            B使用B的私钥加密数据给A端， A使用B的公钥解密数据。
            """

### 26.2: 商城后端和支付宝之间互换公钥： ###

*  0： 创建payment子应用：
 *  1： 安装： pip install python-alipay-sdk==1.8.0 -i https://pypi.tuna.tsinghua.edu.cn/simple
 *  2： 在payment/keys下存储公私密钥：
    
        # 1：在payment中创建keys文件夹专门存储秘钥。
        # 2: 在keys文件夹下执行： openssl命令;

3: 执行命令生成私钥: genrsa -out app\_private\_key.pem 2048

4: 执行命令生成公钥: rsa -in app\_private\_key.pem -pubout -out app\_public\_key.pem

*  3： 商城后端和支付宝后端交换公钥：
 *  4： 设置：
    
        # 支付宝参数
        ALIPAY_APPID = '2016091600526851' # 应用ID
        ALIPAY_DEBUG = True # 调试模式，对接沙箱应用时为True,对接正式应用时为False
        ALIPAY_URL = 'https://openapi.alipaydev.com/gateway.do' # 对接支付宝的网关，如果对接沙箱应用就是测试网关
        
        # 用户支付成功过之后，转而请求到美多的地址
        ALIPAY_RETURN_URL = "http://www.meiduo.site:8080/pay_success.html" # 支付成功后的回调地址

### 16.3: 返回支付宝的支付链接： ###

*  apps/payment/views.py
    
        # 支付接口1：扫码支付页面url获取
        import os
        
        from alipay import AliPay
        from django.conf import settings
        from django.http import JsonResponse
        from django.views import View
        
        from apps.orders.models import OrderInfo
        
        
        class PaymentView(View):
            def get(self, request, order_id):
                # 1、提取参数
                # 2、校验参数
                # 3、业务处理 —— 调用支付宝sdk获取扫码支付url
                # (1)、构建alipay支付对象
                alipay = AliPay(
                    settings.ALIPAY_APPID,  # 支付应用id
                    app_notify_url=None,  # 支付成功之后，支付宝回调地址
                    app_private_key_path=os.path.join(
                        os.path.dirname(os.path.abspath(__file__)),
                        'keys/app_private_key.pem'
                    ),
                    alipay_public_key_path=os.path.join(
                        os.path.dirname(os.path.abspath(__file__)),
                        'keys/alipay_public_key.pem'
                    ),
                    sign_type='RSA2',
                    debug=settings.ALIPAY_DEBUG
        
                )
        
                try:
                    order = OrderInfo.objects.get(pk=order_id)
                except OrderInfo.DoesNotExist as e:
                    print(e)
                    return JsonResponse({
              'code': 400, 'errmsg': '订单不存在'})
        
                # (2)、找对象里面的方法获取支付参数
                # api_alipay_trade_page_pay：获取网页端支付页面url参数
                query_params = alipay.api_alipay_trade_page_pay(
                    subject='美多商城支付%s' % order_id,
                    out_trade_no=order_id,
                    total_amount=float(order.total_amount),
                    return_url=settings.ALIPAY_RETURN_URL,  # 用户支付成功，请求美多的页面
                )
        
                # 扫码支付要么链接是：'https://openapi.alipaydev.com/gateway.do?<支付参数>'
                # (3)、拼接支付扫码页面url
                alipay_url = settings.ALIPAY_URL + '?' + query_params
        
                # 4、构建响应
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'alipay_url': alipay_url})
 *  路由：
    
        from django.urls import re_path
        from . import views
        
        urlpatterns = [
          	# 支付接口1:获取扫码支付页面url
            re_path(r'^payment/(?P<order_id>\d+)/$', views.PaymentView.as_view()),
        
        ]

### 16.4:支付成功与订单绑定： ###

*  新建模型类：然后迁移建表。
    
        from django.db import models
        from apps.orders.models import OrderInfo
        from meiduo_mall.utils.models import BaseModel
        
        class Payment(BaseModel):
            """支付信息"""
            order = models.ForeignKey(OrderInfo, on_delete=models.CASCADE, verbose_name='订单')
            trade_id = models.CharField(max_length=100, unique=True, null=True, blank=True, verbose_name="支付编号")
        
            class Meta:
                db_table = 'tb_payment'
 *  视图：
    
        # 接口二：支付成功，订单号绑定
        class PaymentStatusView(View):
        
            def get(self, request):
                alipay = AliPay(
                    settings.ALIPAY_APPID,  # 支付应用id
                    app_notify_url=None,  # 支付成功之后，支付宝回调地址
                    app_private_key_path=os.path.join(
                        os.path.dirname(os.path.abspath(__file__)),
                        'keys/app_private_key.pem'
                    ),
                    alipay_public_key_path=os.path.join(
                        os.path.dirname(os.path.abspath(__file__)),
                        'keys/alipay_public_key.pem'
                    ),
                    sign_type='RSA2',
                    debug=settings.ALIPAY_DEBUG
        
                )
        
                # 1、校验支付宝参数
                data = request.GET # Django查询字符串参数，类型是QueryDict
                data = data.dict() # QueryDict  转化成  dict
                sign = data.get('sign') # 签名 --> 使用该签名参数校验支付数据的有效性
        
                if not alipay.verify(data, signature=sign):
                    # 校验失败，参数有误
                    return JsonResponse({
              'code': 400, 'errmsg': '支付有误'})
        
                out_trade_no = data.get('out_trade_no') # 接口1中传递的order_id
                trade_no = data.get('trade_no') # 支付宝订单流水号
        
                try:
                    Payment.objects.create(
                        order_id=out_trade_no, # 美多订单号
                        trade_id=trade_no # 支付宝订单流水号
                    )
                except Exception as e:
                    print(e)
                    return JsonResponse({
              'code': 500, 'errmsg': '新建支付订单失败'})
        
                order = OrderInfo.objects.get(pk=out_trade_no)
                order.status = OrderInfo.ORDER_STATUS_ENUM['UNSEND']
                order.save()
        
        
                # 2、绑定美多商城订单
                return JsonResponse({
              'code': 0, 'errmsg': 'ok', 'trade_id': trade_no})
 *  路由：
    
        from django.urls import re_path
        from . import views
        
        urlpatterns = [
          	# 支付接口2:绑定支付订单
            re_path(r'^payment/status/$', views.PaymentStatusView.as_view()),
        ]