Flask开发实现用户的注册和登录功能

短命女 2022-10-07 11:47 256阅读 0赞

# 前言 #

Flask开发实现用户的注册和登录功能

--------------------

# 用户注册页面开发(上)-完成注册流程 #

from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField
    
    
    class RegisterForm(FlaskForm):
        """ 用户注册 """
        username = StringField(label='用户名', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户名'
        })
        nickname = StringField(label='用户昵称', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户昵称'
        })
        password = PasswordField(label='密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入密码'
        })
        confirm_password = PasswordField(label='确认密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入确认密码'
        })

from flask import Blueprint, render_template, flash, redirect, url_for
    
    from accounts.forms import RegisterForm
    from models import User, db, UserProfile
    
    accounts = Blueprint('accounts', __name__,
                         template_folder='templates',
                         static_folder='../assets')
    
    
    @accounts.route('/login')
    def login():
        """ 登录页面 """
        return render_template('login.html')
    
    
    @accounts.route('/register', methods=['GET', 'POST'])
    def register():
        """ 注册 """
        form = RegisterForm()
        if form.validate_on_submit():
            # 1. 获取表单信息
            username = form.username.data
            password = form.password.data
            nickname = form.nickname.data
            # 2. 添加到db.session
            try:
                user_obj = User(username=username, password=password, nickname=nickname)
                db.session.add(user_obj)
                profile = UserProfile(username=username, user=user_obj)
                db.session.add(profile)
                db.session.commit()
                # 3. 跳转到登录的页面
                flash('注册成功，请登录', 'success')
                return redirect(url_for('accounts.login'))
            except Exception as e:
                print(e)
                flash('注册失败，请稍后再试', 'danger')
        return render_template('register.html', form=form)
    
    
    @accounts.route('/mine')
    def mine():
        """ 个人中心 """
        return render_template('mine.html')

""" 常量配置 """
    from enum import Enum
    
    
    class UserStatus(Enum):
        """ 用户状态 """
        # 启用，可以登录系统
        USER_ACTIVE = 1
        # 禁用，不能登录系统
        USER_IN_ACTIVE = 0
    
    
    class UserRole(Enum):
        """ 用户的角色 """
        # 普通用户，可以使用前台功能
        COMMON = 0
        # 管理员用户，可以使用后台管理功能
        ADMIN = 1
        # 超级管理员用户，可以删除敏感数据，如用户等
        SUPER_ADMIN = 2

def number_split(num):
        """
        数字格式化
        12345678 => 12,345,678
        :param num: 需要格式化的数字
        :return: 格式化后的字符串
        """
        return '{:,}'.format(int(num))

from flask import Blueprint, render_template, request, abort
    
    from models import Question
    
    qa = Blueprint('qa', __name__,
                   template_folder='templates',
                   static_folder='../assets')
    
    
    @qa.route('/')
    def index():
        """ 首页 """
        return render_template('index.html')
    
    
    @qa.route('/follow')
    def follow():
        """ 关注 """
        per_page = 20  # 每页数据的大小
        page = int(request.args.get('page', 1))
        page_data = Question.query.filter_by(is_valid=True).paginate(
            page=page, per_page=per_page)
        return render_template('follow.html', page_data=page_data)
    
    
    @qa.route('/write')
    def write():
        """ 写文章，提问 """
        return render_template('write.html')
    
    
    @qa.route('/detail/<int:q_id>')
    def detail(q_id):
        """ 问题详情 """
        # 1. 查询问题信息
        question = Question.query.get(q_id)
        if not question.is_valid:
            abort(404)
        # 2. 展示第一条回答信息
        answer = question.answer_list.filter_by(is_valid=True).first()
        return render_template('detail.html', question=question, answer=answer)

from flask import Flask
    
    from models import db
    from accounts.views import accounts
    from qa.views import qa
    from utils.filters import number_split
    
    app = Flask(__name__, static_folder='assets')
    # 从配置文件加载配置
    app.config.from_object('conf.Config')
    
    # 数据库初始化
    db.init_app(app)
    
    # 注册蓝图
    app.register_blueprint(accounts, url_prefix='/accounts')
    app.register_blueprint(qa, url_prefix='/')
    
    # 注册过滤器
    app.jinja_env.filters['number_split'] = number_split

import os
    
    
    class Config(object):
        """ 项目的配置文件 """
        # 数据库连接URI
        SQLALCHEMY_DATABASE_URI = 'mysql://root:@localhost/flask_qa'
        SQLALCHEMY_TRACK_MODIFICATIONS = True
        # flash, form wtf
        SECRET_KEY = 'abcdsacb12312'
        # 文件上传的根路径
        MEDIA_ROOT = os.path.join(os.path.dirname(__file__), 'medias')

from datetime import datetime
    
    from flask_sqlalchemy import SQLAlchemy
    
    from utils import constants
    
    db = SQLAlchemy()
    
    
    class User(db.Model):
        """ 用户模型 """
        __tablename__ = 'accounts_user'
        id = db.Column(db.Integer, primary_key=True, autoincrement=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户昵称
        nickname = db.Column(db.String(64))
        password = db.Column(db.String(256), nullable=False)
        # 用户的头像地址
        avatar = db.Column(db.String(256))
    
        # 是否有效，无效用户将不能登录系统
        status = db.Column(db.SmallInteger,
                           default=constants.UserStatus.USER_ACTIVE.value,
                           comment='用户状态')
        # 是否是超级管理员，管理员可以对所有内容进行管理
        is_super = db.Column(db.SmallInteger,
                             default=constants.UserRole.COMMON.value)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # profile = db.relationship('UserProfile')
    
    
    class UserProfile(db.Model):
        """ 用户详细信息 """
        __tablename__ = 'accounts_user_profile'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户真实姓名
        real_name = db.Column(db.String(64))
        # 用户的格言
        maxim = db.Column(db.String(128))
        # 性别
        sex = db.Column(db.String(16))
        # 地址
        address = db.Column(db.String(256))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立用户的一对一关系属性user.profile profile.user
        user = db.relationship('User', backref=db.backref('profile', uselist=False))
    
    
    class UserLoginHistory(db.Model):
        __tablename__ = 'accounts_login_history'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), nullable=False)
        # 账号平台
        login_type = db.Column(db.String(32))
        # IP地址
        ip = db.Column(db.String(32))
        # user-agent
        ua = db.Column(db.String(128))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.history_list
        user = db.relationship('User', backref=db.backref('history_list', lazy='dynamic'))
    
    
    class Question(db.Model):
        """ 问题 """
        __tablename__ = 'qa_question'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 问题标题
        title = db.Column(db.String(128), nullable=False)
        # 问题描述
        desc = db.Column(db.String(256))
        # 问题图片
        img = db.Column(db.String(256))
        # 问题详情
        content = db.Column(db.Text, nullable=False)
        # 浏览人数
        view_count = db.Column(db.Integer, default=0)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 排序
        reorder = db.Column(db.Integer, default=0)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.question_list
        user = db.relationship('User', backref=db.backref('question_list', lazy='dynamic'))
    
        @property
        def comment_count(self):
            """ 评论数量 """
            return self.question_comment_list.filter_by(is_valid=True).count()
    
        @property
        def follow_count(self):
            """ 关注数量 """
            return self.question_follow_list.filter_by(is_valid=True).count()
    
        @property
        def answer_count(self):
            return self.answer_list.filter_by(is_valid=True).count()
    
    
    class QuestionTags(db.Model):
        """ 问题下的标签 """
        __tablename__ = 'qa_question_tags'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 标签名称
        tag_name = db.Column(db.String(16), nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
    
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('tag_list', lazy='dynamic'))
    
    
    class Answer(db.Model):
        """ 问题的回答 """
        __tablename__ = 'qa_answer'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 回答的内容详情
        content = db.Column(db.Text, nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('answer_list', lazy='dynamic'))
    
        @property
        def love_count(self):
            """ 点赞的数量 """
            return self.answer_love_list.count()
    
    
    class AnswerComment(db.Model):
        """ 回答的评论 """
        __tablename__ = 'qa_answer_comment'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 评论内容
        content = db.Column(db.String(512), nullable=False)
        # 赞同人数
        love_count = db.Column(db.Integer, default=0)
        # 评论是否公开
        is_public = db.Column(db.Boolean, default=True)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 回复ID
        reply_id = db.Column(db.Integer, db.ForeignKey('qa_answer_comment.id'), nullable=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_comment_list', lazy='dynamic'))
    
    
    class AnswerLove(db.Model):
        """ 回答点赞 """
        __tablename__ = 'qa_answer_love'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_love_list', lazy='dynamic'))
    
    
    class AnswerCollect(db.Model):
        """ 收藏的回答 """
        __tablename__ = 'qa_answer_collect'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_collect_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_collect_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_collect_list', lazy='dynamic'))
    
    
    class QuestionFollow(db.Model):
        """ 关注的问题 """
        __tablename__ = 'qa_question_follow'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime)
        is_valid = db.Column(db.Boolean, default=True, comment='逻辑删除')
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('question_follow_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_follow_list', lazy='dynamic'))

# 用户注册页面开发(下)-注册表单验证 #

import hashlib
    
    from flask import Blueprint, render_template, flash, redirect, url_for
    
    from accounts.forms import RegisterForm
    from models import User, db, UserProfile
    
    accounts = Blueprint('accounts', __name__,
                         template_folder='templates',
                         static_folder='../assets')
    
    
    @accounts.route('/login')
    def login():
        """ 登录页面 """
        return render_template('login.html')
    
    
    @accounts.route('/register', methods=['GET', 'POST'])
    def register():
        """ 注册 """
        form = RegisterForm()
        if form.validate_on_submit():
            user_obj = form.register()
            if user_obj:
                # 跳转到登录的页面
                flash('注册成功，请登录', 'success')
                return redirect(url_for('accounts.login'))
            else:
                flash('注册失败，请稍后再试', 'danger')
        return render_template('register.html', form=form)
    
    
    @accounts.route('/mine')
    def mine():
        """ 个人中心 """
        return render_template('mine.html')

import re
    
    from wtforms import ValidationError
    
    
    def phone_required(form, field):
        """ 自定义的手机号码的验证 """
        # 强制验证用户名为手机号
        username = field.data
        pattern = r'^1[0-9]{10}$'
        if not re.search(pattern, username):
            raise ValidationError('请输入手机号码')
        return field

# 简单实现用户的登录 #

import hashlib
    
    from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField, ValidationError
    from wtforms.validators import DataRequired, Length, EqualTo
    
    from models import User, db, UserProfile
    from utils import constants
    from utils.validators import phone_required
    
    
    class RegisterForm(FlaskForm):
        """ 用户注册 """
        username = StringField(label='用户名', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户名'
        }, validators=[DataRequired('请输入用户名'), phone_required])
        nickname = StringField(label='用户昵称', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户昵称'
        }, validators=[DataRequired('请输入用户昵称'),
                       Length(min=2, max=20, message='昵称长度在2-20之间')])
        password = PasswordField(label='密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入密码'
        }, validators=[DataRequired('请输入密码')])
        confirm_password = PasswordField(label='确认密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入确认密码'
        }, validators=[DataRequired('请输入确认密码'),
                       EqualTo('password', message='两次密码输入不一致')])
    
        def validate_username(self, field):
            """ 检测用户名是否已经存在 """
            user = User.query.filter_by(username=field.data).first()
            if user:
                raise ValidationError('该用户名已经存在')
            return field
    
        def register(self):
            """ 自定义的用户注册函数 """
            # 1. 获取表单信息
            username = self.username.data
            password = self.password.data
            nickname = self.nickname.data
            # 2. 添加到db.session
            try:
                # 将密码加密存储
                password = hashlib.sha256(password.encode()).hexdigest()
                user_obj = User(username=username, password=password, nickname=nickname)
                db.session.add(user_obj)
                profile = UserProfile(username=username, user=user_obj)
                db.session.add(profile)
                db.session.commit()
                return user_obj
            except Exception as e:
                print(e)
            return None
    
    
    class LoginForm(FlaskForm):
        """ 用户登录 """
        username = StringField(label='用户名', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户名'
        }, validators=[DataRequired('请输入用户名'), phone_required])
        password = PasswordField(label='密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入密码'
        }, validators=[DataRequired('请输入密码')])
    
        def validate(self):
            result = super().validate()
            username = self.username.data
            password = self.password.data
            if result:
                # TODO 验证加密后的密码是否正确
                user = User.query.filter_by(username=username, password=password).first()
                if user is None:
                    result = False
                    self.username.errors = ['用户名或者是密码错误']
                elif user.status == constants.UserStatus.USER_IN_ACTIVE.value:
                    result = False
                    self.username.errors = ['用户已被禁用']
            return result

import hashlib
    
    from flask import Blueprint, render_template, flash, redirect, url_for, session, request
    
    from accounts.forms import RegisterForm, LoginForm
    from models import User, db, UserProfile, UserLoginHistory
    
    accounts = Blueprint('accounts', __name__,
                         template_folder='templates',
                         static_folder='../assets')
    
    
    @accounts.route('/login', methods=['GET', 'POST'])
    def login():
        """ 登录页面 """
        form = LoginForm()
        if form.validate_on_submit():
            print('正在登录')
            username = form.username.data
            password = form.password.data
            # 1. 查找对应的用户
            # TODO 验证加密后的密码是否正确
            user = User.query.filter_by(username=username, password=password).first()
            # 2. 登录用户
            session['user_id'] = user.id
            # 3. 记录日志
            ip = request.remote_addr
            ua = request.headers.get('user-agent', None)
            obj = UserLoginHistory(username=username, ip=ip, ua=ua, user=user)
            db.session.add(obj)
            db.session.commit()
            # 4. 跳转到首页
            flash('{}, 欢迎回来'.format(user.nickname), 'success')
            return redirect(url_for('qa.index'))
        else:
            print(form.errors)
        return render_template('login.html', form=form)
    
    
    @accounts.route('/register', methods=['GET', 'POST'])
    def register():
        """ 注册 """
        form = RegisterForm()
        if form.validate_on_submit():
            user_obj = form.register()
            if user_obj:
                # 跳转到登录的页面
                flash('注册成功，请登录', 'success')
                return redirect(url_for('accounts.login'))
            else:
                flash('注册失败，请稍后再试', 'danger')
        return render_template('register.html', form=form)
    
    
    @accounts.route('/mine')
    def mine():
        """ 个人中心 """
        return render_template('mine.html')

from flask import Flask, session, g
    
    from models import db, User
    from accounts.views import accounts
    from qa.views import qa
    from utils.filters import number_split
    
    app = Flask(__name__, static_folder='assets')
    # 从配置文件加载配置
    app.config.from_object('conf.Config')
    
    # 数据库初始化
    db.init_app(app)
    
    # 注册蓝图
    app.register_blueprint(accounts, url_prefix='/accounts')
    app.register_blueprint(qa, url_prefix='/')
    
    # 注册过滤器
    app.jinja_env.filters['number_split'] = number_split
    
    
    @app.before_request
    def before_request():
        """ 如果有用户id,设置到全局对象 """
        user_id = session.get('user_id', None)
        if user_id:
            user = User.query.get(user_id)
            print(user)
            g.current_user = user

from datetime import datetime
    
    from flask_sqlalchemy import SQLAlchemy
    
    from utils import constants
    
    db = SQLAlchemy()
    
    
    class User(db.Model):
        """ 用户模型 """
        __tablename__ = 'accounts_user'
        id = db.Column(db.Integer, primary_key=True, autoincrement=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户昵称
        nickname = db.Column(db.String(64))
        password = db.Column(db.String(256), nullable=False)
        # 用户的头像地址
        avatar = db.Column(db.String(256))
    
        # 是否有效，无效用户将不能登录系统
        status = db.Column(db.SmallInteger,
                           default=constants.UserStatus.USER_ACTIVE.value,
                           comment='用户状态')
        # 是否是超级管理员，管理员可以对所有内容进行管理
        is_super = db.Column(db.SmallInteger,
                             default=constants.UserRole.COMMON.value)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # profile = db.relationship('UserProfile')
    
        def __str__(self):
            return self.nickname
    
    
    class UserProfile(db.Model):
        """ 用户详细信息 """
        __tablename__ = 'accounts_user_profile'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户真实姓名
        real_name = db.Column(db.String(64))
        # 用户的格言
        maxim = db.Column(db.String(128))
        # 性别
        sex = db.Column(db.String(16))
        # 地址
        address = db.Column(db.String(256))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立用户的一对一关系属性user.profile profile.user
        user = db.relationship('User', backref=db.backref('profile', uselist=False))
    
    
    class UserLoginHistory(db.Model):
        __tablename__ = 'accounts_login_history'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), nullable=False)
        # 账号平台
        login_type = db.Column(db.String(32))
        # IP地址
        ip = db.Column(db.String(32))
        # user-agent
        ua = db.Column(db.String(128))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.history_list
        user = db.relationship('User', backref=db.backref('history_list', lazy='dynamic'))
    
    
    class Question(db.Model):
        """ 问题 """
        __tablename__ = 'qa_question'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 问题标题
        title = db.Column(db.String(128), nullable=False)
        # 问题描述
        desc = db.Column(db.String(256))
        # 问题图片
        img = db.Column(db.String(256))
        # 问题详情
        content = db.Column(db.Text, nullable=False)
        # 浏览人数
        view_count = db.Column(db.Integer, default=0)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 排序
        reorder = db.Column(db.Integer, default=0)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.question_list
        user = db.relationship('User', backref=db.backref('question_list', lazy='dynamic'))
    
        @property
        def comment_count(self):
            """ 评论数量 """
            return self.question_comment_list.filter_by(is_valid=True).count()
    
        @property
        def follow_count(self):
            """ 关注数量 """
            return self.question_follow_list.filter_by(is_valid=True).count()
    
        @property
        def answer_count(self):
            return self.answer_list.filter_by(is_valid=True).count()
    
    
    class QuestionTags(db.Model):
        """ 问题下的标签 """
        __tablename__ = 'qa_question_tags'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 标签名称
        tag_name = db.Column(db.String(16), nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
    
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('tag_list', lazy='dynamic'))
    
    
    class Answer(db.Model):
        """ 问题的回答 """
        __tablename__ = 'qa_answer'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 回答的内容详情
        content = db.Column(db.Text, nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('answer_list', lazy='dynamic'))
    
        @property
        def love_count(self):
            """ 点赞的数量 """
            return self.answer_love_list.count()
    
    
    class AnswerComment(db.Model):
        """ 回答的评论 """
        __tablename__ = 'qa_answer_comment'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 评论内容
        content = db.Column(db.String(512), nullable=False)
        # 赞同人数
        love_count = db.Column(db.Integer, default=0)
        # 评论是否公开
        is_public = db.Column(db.Boolean, default=True)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 回复ID
        reply_id = db.Column(db.Integer, db.ForeignKey('qa_answer_comment.id'), nullable=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_comment_list', lazy='dynamic'))
    
    
    class AnswerLove(db.Model):
        """ 回答点赞 """
        __tablename__ = 'qa_answer_love'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_love_list', lazy='dynamic'))
    
    
    class AnswerCollect(db.Model):
        """ 收藏的回答 """
        __tablename__ = 'qa_answer_collect'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_collect_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_collect_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_collect_list', lazy='dynamic'))
    
    
    class QuestionFollow(db.Model):
        """ 关注的问题 """
        __tablename__ = 'qa_question_follow'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime)
        is_valid = db.Column(db.Boolean, default=True, comment='逻辑删除')
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('question_follow_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_follow_list', lazy='dynamic'))

# Flask实现登录验证 #

import hashlib
    
    from flask import request
    from flask_login import login_user
    from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField, ValidationError
    from wtforms.validators import DataRequired, Length, EqualTo
    
    from models import User, db, UserProfile, UserLoginHistory
    from utils import constants
    from utils.validators import phone_required
    
    
    class RegisterForm(FlaskForm):
        """ 用户注册 """
        username = StringField(label='用户名', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户名'
        }, validators=[DataRequired('请输入用户名'), phone_required])
        nickname = StringField(label='用户昵称', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户昵称'
        }, validators=[DataRequired('请输入用户昵称'),
                       Length(min=2, max=20, message='昵称长度在2-20之间')])
        password = PasswordField(label='密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入密码'
        }, validators=[DataRequired('请输入密码')])
        confirm_password = PasswordField(label='确认密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入确认密码'
        }, validators=[DataRequired('请输入确认密码'),
                       EqualTo('password', message='两次密码输入不一致')])
    
        def validate_username(self, field):
            """ 检测用户名是否已经存在 """
            user = User.query.filter_by(username=field.data).first()
            if user:
                raise ValidationError('该用户名已经存在')
            return field
    
        def register(self):
            """ 自定义的用户注册函数 """
            # 1. 获取表单信息
            username = self.username.data
            password = self.password.data
            nickname = self.nickname.data
            # 2. 添加到db.session
            try:
                # 将密码加密存储
                password = hashlib.sha256(password.encode()).hexdigest()
                user_obj = User(username=username, password=password, nickname=nickname)
                db.session.add(user_obj)
                profile = UserProfile(username=username, user=user_obj)
                db.session.add(profile)
                db.session.commit()
                return user_obj
            except Exception as e:
                print(e)
            return None
    
    
    class LoginForm(FlaskForm):
        """ 用户登录 """
        username = StringField(label='用户名', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入用户名'
        }, validators=[DataRequired('请输入用户名'), phone_required])
        password = PasswordField(label='密码', render_kw={ 
            'class': 'form-control input-lg',
            'placeholder': '请输入密码'
        }, validators=[DataRequired('请输入密码')])
    
        def validate(self):
            result = super().validate()
            username = self.username.data
            password = self.password.data
            if result:
                # TODO 验证加密后的密码是否正确
                user = User.query.filter_by(username=username, password=password).first()
                if user is None:
                    result = False
                    self.username.errors = ['用户名或者是密码错误']
                elif user.status == constants.UserStatus.USER_IN_ACTIVE.value:
                    result = False
                    self.username.errors = ['用户已被禁用']
            return result
    
        def do_login(self):
            """ 执行登录逻辑代码 """
            username = self.username.data
            password = self.password.data
            try:
                # 1. 查找对应的用户
                # TODO 验证加密后的密码是否正确
                user = User.query.filter_by(username=username, password=password).first()
                # 2. 登录用户
                # session['user_id'] = user.id
                login_user(user)
                # 3. 记录日志
                ip = request.remote_addr
                ua = request.headers.get('user-agent', None)
                obj = UserLoginHistory(username=username, ip=ip, ua=ua, user=user)
                db.session.add(obj)
                db.session.commit()
                return user
            except Exception as e:
                print(e)
            return None

import hashlib
    
    from flask import Blueprint, render_template, flash, redirect, url_for, session, request
    from flask_login import login_user, logout_user
    
    from accounts.forms import RegisterForm, LoginForm
    from models import User, db, UserProfile, UserLoginHistory
    
    accounts = Blueprint('accounts', __name__,
                         template_folder='templates',
                         static_folder='../assets')
    
    
    @accounts.route('/login', methods=['GET', 'POST'])
    def login():
        """ 登录页面 """
        form = LoginForm()
        next_url = request.values.get('next', url_for('qa.index'))
        if form.validate_on_submit():
            user = form.do_login()
            if user:
                # 4. 跳转到首页
                flash('{}, 欢迎回来'.format(user.nickname), 'success')
                return redirect(next_url)
            else:
                flash('登录失败，请稍后重试', 'danger')
        # else:
        # print(form.errors)
        return render_template('login.html', form=form, next_url=next_url)
    
    
    @accounts.route('/logout')
    def logout():
        """ 退出登录 """
        # 自定义登录的逻辑代码
        # session['user_id'] = ''
        # g.current_user = None
        logout_user()
        flash('欢迎下次再来', 'success')
        return redirect(url_for('accounts.login'))
    
    
    @accounts.route('/register', methods=['GET', 'POST'])
    def register():
        """ 注册 """
        form = RegisterForm()
        if form.validate_on_submit():
            user_obj = form.register()
            if user_obj:
                # 跳转到登录的页面
                flash('注册成功，请登录', 'success')
                return redirect(url_for('accounts.login'))
            else:
                flash('注册失败，请稍后再试', 'danger')
        return render_template('register.html', form=form)
    
    
    @accounts.route('/mine')
    def mine():
        """ 个人中心 """
        return render_template('mine.html')

from flask import Blueprint, render_template, request, abort
    from flask_login import login_required
    
    from models import Question
    
    qa = Blueprint('qa', __name__,
                   template_folder='templates',
                   static_folder='../assets')
    
    
    @qa.route('/')
    def index():
        """ 首页 """
        return render_template('index.html')
    
    
    @qa.route('/follow')
    def follow():
        """ 关注 """
        per_page = 20  # 每页数据的大小
        page = int(request.args.get('page', 1))
        page_data = Question.query.filter_by(is_valid=True).paginate(
            page=page, per_page=per_page)
        return render_template('follow.html', page_data=page_data)
    
    
    @qa.route('/write')
    @login_required
    def write():
        """ 写文章，提问 """
        return render_template('write.html')
    
    
    @qa.route('/detail/<int:q_id>')
    def detail(q_id):
        """ 问题详情 """
        # 1. 查询问题信息
        question = Question.query.get(q_id)
        if not question.is_valid:
            abort(404)
        # 2. 展示第一条回答信息
        answer = question.answer_list.filter_by(is_valid=True).first()
        return render_template('detail.html', question=question, answer=answer)

from flask import Flask, session, g
    from flask_login import LoginManager
    
    from models import db, User
    from accounts.views import accounts
    from qa.views import qa
    from utils.filters import number_split
    
    app = Flask(__name__, static_folder='assets')
    # 从配置文件加载配置
    app.config.from_object('conf.Config')
    
    # 数据库初始化
    db.init_app(app)
    
    # 登录验证
    login_manager = LoginManager()
    login_manager.login_view = "accounts.login"
    login_manager.login_message = '请登录'
    login_manager.login_message_category = "danger"
    login_manager.init_app(app)
    
    # 注册蓝图
    app.register_blueprint(accounts, url_prefix='/accounts')
    app.register_blueprint(qa, url_prefix='/')
    
    # 注册过滤器
    app.jinja_env.filters['number_split'] = number_split
    
    #
    # @app.before_request
    # def before_request():
    # """ 如果有用户id,设置到全局对象 """
    # user_id = session.get('user_id', None)
    # if user_id:
    # user = User.query.get(user_id)
    # print(user)
    # g.current_user = user
    
    
    @login_manager.user_loader
    def load_user(user_id):
        return User.query.get(user_id)

from datetime import datetime
    
    from flask_sqlalchemy import SQLAlchemy
    
    from utils import constants
    
    db = SQLAlchemy()
    
    
    class User(db.Model):
        """ 用户模型 """
        __tablename__ = 'accounts_user'
        id = db.Column(db.Integer, primary_key=True, autoincrement=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户昵称
        nickname = db.Column(db.String(64))
        password = db.Column(db.String(256), nullable=False)
        # 用户的头像地址
        avatar = db.Column(db.String(256))
    
        # 是否有效，无效用户将不能登录系统
        status = db.Column(db.SmallInteger,
                           default=constants.UserStatus.USER_ACTIVE.value,
                           comment='用户状态')
        # 是否是超级管理员，管理员可以对所有内容进行管理
        is_super = db.Column(db.SmallInteger,
                             default=constants.UserRole.COMMON.value)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # profile = db.relationship('UserProfile')
    
        @property
        def is_authenticated(self):
            return True
    
        @property
        def is_active(self):
            """ 有效的用户才能登录系统 """
            return self.status == constants.UserStatus.USER_ACTIVE.value
    
        @property
        def is_anonymous(self):
            return False
    
        def get_id(self):
            return '{}'.format(self.id)
    
        def __str__(self):
            return self.nickname
    
    
    class UserProfile(db.Model):
        """ 用户详细信息 """
        __tablename__ = 'accounts_user_profile'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), unique=True, nullable=False)
        # 用户真实姓名
        real_name = db.Column(db.String(64))
        # 用户的格言
        maxim = db.Column(db.String(128))
        # 性别
        sex = db.Column(db.String(16))
        # 地址
        address = db.Column(db.String(256))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime,
                               default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立用户的一对一关系属性user.profile profile.user
        user = db.relationship('User', backref=db.backref('profile', uselist=False))
    
    
    class UserLoginHistory(db.Model):
        __tablename__ = 'accounts_login_history'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 用户名，用于登录
        username = db.Column(db.String(64), nullable=False)
        # 账号平台
        login_type = db.Column(db.String(32))
        # IP地址
        ip = db.Column(db.String(32))
        # user-agent
        ua = db.Column(db.String(128))
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.history_list
        user = db.relationship('User', backref=db.backref('history_list', lazy='dynamic'))
    
    
    class Question(db.Model):
        """ 问题 """
        __tablename__ = 'qa_question'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 问题标题
        title = db.Column(db.String(128), nullable=False)
        # 问题描述
        desc = db.Column(db.String(256))
        # 问题图片
        img = db.Column(db.String(256))
        # 问题详情
        content = db.Column(db.Text, nullable=False)
        # 浏览人数
        view_count = db.Column(db.Integer, default=0)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 排序
        reorder = db.Column(db.Integer, default=0)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 建立与用户的一对多属性,user.question_list
        user = db.relationship('User', backref=db.backref('question_list', lazy='dynamic'))
    
        @property
        def comment_count(self):
            """ 评论数量 """
            return self.question_comment_list.filter_by(is_valid=True).count()
    
        @property
        def follow_count(self):
            """ 关注数量 """
            return self.question_follow_list.filter_by(is_valid=True).count()
    
        @property
        def answer_count(self):
            return self.answer_list.filter_by(is_valid=True).count()
    
    
    class QuestionTags(db.Model):
        """ 问题下的标签 """
        __tablename__ = 'qa_question_tags'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 标签名称
        tag_name = db.Column(db.String(16), nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
    
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('tag_list', lazy='dynamic'))
    
    
    class Answer(db.Model):
        """ 问题的回答 """
        __tablename__ = 'qa_answer'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 回答的内容详情
        content = db.Column(db.Text, nullable=False)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('answer_list', lazy='dynamic'))
    
        @property
        def love_count(self):
            """ 点赞的数量 """
            return self.answer_love_list.count()
    
    
    class AnswerComment(db.Model):
        """ 回答的评论 """
        __tablename__ = 'qa_answer_comment'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 评论内容
        content = db.Column(db.String(512), nullable=False)
        # 赞同人数
        love_count = db.Column(db.Integer, default=0)
        # 评论是否公开
        is_public = db.Column(db.Boolean, default=True)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 最后修改的时间
        updated_at = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
        # 回复ID
        reply_id = db.Column(db.Integer, db.ForeignKey('qa_answer_comment.id'), nullable=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_comment_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_comment_list', lazy='dynamic'))
    
    
    class AnswerLove(db.Model):
        """ 回答点赞 """
        __tablename__ = 'qa_answer_love'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_love_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_love_list', lazy='dynamic'))
    
    
    class AnswerCollect(db.Model):
        """ 收藏的回答 """
        __tablename__ = 'qa_answer_collect'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        # 创建时间
        created_at = db.Column(db.DateTime, default=datetime.now)
        # 逻辑删除
        is_valid = db.Column(db.Boolean, default=True)
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
        # 关联答案
        answer_id = db.Column(db.Integer, db.ForeignKey('qa_answer.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('answer_collect_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_collect_list', lazy='dynamic'))
        # 建立与答案的一对多属性
        answer = db.relationship('Answer', backref=db.backref('answer_collect_list', lazy='dynamic'))
    
    
    class QuestionFollow(db.Model):
        """ 关注的问题 """
        __tablename__ = 'qa_question_follow'
        id = db.Column(db.Integer, primary_key=True)  # 主键
        created_at = db.Column(db.DateTime)
        is_valid = db.Column(db.Boolean, default=True, comment='逻辑删除')
        # 关联用户
        user_id = db.Column(db.Integer, db.ForeignKey('accounts_user.id'))
        # 关联问题
        q_id = db.Column(db.Integer, db.ForeignKey('qa_question.id'))
    
        # 建立与用户的一对多属性
        user = db.relationship('User', backref=db.backref('question_follow_list', lazy='dynamic'))
        # 建立与问题的一对多属性
        question = db.relationship('Question', backref=db.backref('question_follow_list', lazy='dynamic'))