40.(后端)根据ID获取用户信息

1.根据ID查询用户接口

为了方便用户快速查看信息，我们后端应该提供一个查询用户信息的接口
通过get请求参数，获取到id，再使用user视图去获取id对应的数据即可

2.到模型中定义获取内容的函数

# /flask_shop/models.py
# 此文件用于建立数据库表的模型

# 需要针对数据库的模型
from flask_shop import db
# 对数据加密         检查密码
from werkzeug.security import generate_password_hash,check_password_hash
from datetime import datetime

# 创建公用数据库模型
class BaseModel:
    # 记录创建的时间
    create_time = db.Column(db.DateTime,default=datetime.now)
    # 记录修改密码的时间
    update_time = db.Column(db.DateTime, default=datetime.now, onupdate = datetime.now)

# 需要继承数据库中的模型
class User(db.Model,BaseModel):
    __tablename__ = 't_user'
    id = db.Column(db.Integer, primary_key = True)
    name = db.Column(db.String(32), unique=True, nullable=False)
    pwd = db.Column(db.String(128))
    nick_name = db.Column(db.String(32))
    phone = db.Column(db.String(11))
    email = db.Column(db.String(32))

    # 对数据库的加密操作

    # # 模拟用户操作
    # u = User() # 获取到对象
    # u.password # 访问获取密码
    # u.password = '123'# 用户输入密码

    # 定义两个装饰器，用于访问密码时使用
    @property
    def password(self):
        return self.pwd
    
    # 用户存储时使用，存的是加密过后的数据，若要访问，得通过property装饰器
    # 用户先输入密码，传入到t_pwd，通过函数的加密返回给self.pwd；用户需要访问时，找到property
    # self.pwd,是数据库中的密码（加密过后）；t_pwd是用户输入的密码（真实密码）
    @password.setter
    def password(self,t_pwd):
        self.pwd = generate_password_hash(t_pwd)
    
    # 用户二次访问之后，需要把加密过后的密码转成真实密码，与用户输入的密码进行比对
    def check_password(self,t_pwd):
        return check_password_hash(self.pwd,t_pwd)

    def to_dict(self):
        return {
            'id':self.id,
            'name': self.name,
            'nick_name':self.nick_name,
            'phone':self.phone,
            'email':self.email
        }
# 建立菜单的数据库
class Menu(db.Model):
    __tablename__ = 't_menu'
    id = db.Column(db.Integer, primary_key = True)
    name = db.Column(db.String(32),unique = True, nullable = False)
    level = db.Column(db.Integer)
    path = db.Column(db.String(32))
    # pid = db.Column(db.Integer)
    pid = db.Column(db.Integer, db.ForeignKey('t_menu.id'))
    # 建立一个自连接的数据，用于做子表
    children = db.relationship('Menu')

    # 由于前端的接收需要给出json数据，不可以直接去获取，所以得单独返回
    def to_dict(self):
        return {
            'id':self.id,
            'name': self.name,
            'level':self.level,
            'path':self.path,
            'pid':self.pid,
            # 子表中的内容需要单独返回，可以做一个递归或者循环
            # 'children': self.get_child_list()
        }
    def get_child_list(self):
        obj_child = self.children
        data = []
        for o in obj_child:
            data.append(o.to_dict)
        return data

3.通过id获取用户信息

先获取到用户的id，使用filter_by获取到模型中的User类，此时，就可以调用刚刚定义模型的方法。

# flask_shop/user/view.py
# 此文件用于处理关于用户的业务逻辑，视图都写在这

# 导入用户的蓝图对象，这里的user不是文件，是在user.py定义好的蓝图对象
from flask import request
from flask_shop.user import user,user_api
from flask_shop import models,db
from flask_restful import Resource
import re
from flask_shop.utils.message import to_dict_msg
from flask_shop.utils.tokens import generate_auth_token,verify_auth_token,login_requed
@user.route("/")
def index():
    return "Hello user"

# 用flask_restful实现注册功能
# 使用flask_restful 必须继承Resource类
class User(Resource):
    # get请求访问
    def get(self):
        # 防止没有用户id产生报错
        try:
            # 通过参数获取用户的id
            id = int(request.args.get('id').strip())
            usr = models.User.query.filter_by(id = id).first()
            print(type(usr))
            if usr:
                return to_dict_msg(200, usr.to_dict(), "获取用户成功！")
            else:
                return to_dict_msg(200, [], '没有此用户')
        except Exception as e:
            print(e)
            return to_dict_msg(10000)
    # post请求访问    
    def post(self):
        name = request.form.get('name')
        pwd= request.form.get('pwd')
        real_pwd = request.form.get('real_pwd')
        nick_name = request.form.get('nick_name')
        phone = request.form.get('phone')
        email = request.form.get('email')
        # 验证数据的正确性
        if not all([name,pwd,real_pwd]):
            return to_dict_msg(10000)
        if len(name)<2:
            return to_dict_msg(10001)
        if len(pwd)<2:
            return to_dict_msg(10012)
        if pwd != real_pwd:
            return to_dict_msg(10013)
        # 正则表达式验证手机号和邮箱
        # ^((13[0-9])|(14[5|7])|(15([0-3]|[5-9]))|(17[013678])|(18[0,5-9]))\\d{8}$
        if not re.match(r'^1[35789]\d{9}$',phone):
            return to_dict_msg(10014)
        if not re.match(r'^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.[a-zA-Z0-9]{2,6}$',email):
            return to_dict_msg(10015)
        # 由于可能在数据库中会抛出异常，还是得做一个尝试
        try:
            # 提交数据
            # 注意这里的密码要加密处理，不可以直接返回给保存到数据库中得变量pwd，返回给函数password
            usr = models.User(name=name, password = pwd, nick_name = nick_name, phone = phone,email = email)
            db.session.add(usr)
            db.session.commit()
            return to_dict_msg(200)
        except Exception as e:
        #     return to_dict_msg(2000)
            print('-------------------------')
            print(e)


# flask_restful注册路由地址
user_api.add_resource(User,'/user')


# 后端登录的实现
# 使用get请求不安全
@user.route('/login',methods=['POST'])
# 调用验证是否登录的装饰器
# @login_requed
def login():
    # 从前端输入框中获取，此时还没写前端使用postman测试
    name = request.form.get('name')
    pwd= request.form.get('pwd')
    # 判断两个是否为非空值
    if not all([name,pwd]):
        return {'status':10000,'msg':'数据不完整'}
    if len(name) > 1:
        # SQLALCHEMY查询语句：获取用户字段，得到实例对象
        usr = models.User.query.filter_by(name =name).first()
        if usr:
            # 调用usr视图中的验证蓝图
            if usr.check_password(pwd):
                # 登录成功生成token，实现免密登录
                token = generate_auth_token(usr.id,10000000000)
                # 用于验证token是否可以使用
                verify_auth_token(token)
                return to_dict_msg(200,data={'token':token})
    return {'status':10001,'msg':'用户名或密码错误'}#防止用户暴力测试

4.Postman测试