管理信息系统 课程设计

                                                                                                     1、系统概要说明

现在，随着网络技术的飞速发展，互联网已经成为了人们发布与获取信息的重要途径之一，所以通过老师要求，本次课程设计我主要是设计一个方便大众浏览娱乐圈中明星的一些新闻，如刘亦菲，对自己感兴趣的新闻进行评论，发表感兴趣的文章等来满足他们的好奇心。这网站的具有的功能有注册，登录，注销，发布，列表展示，详情页，评论（列表显示），用户通过注册、登录到网站，可以进行发帖、评论、点赞、收藏等功能。用户可以修改自己的头像、密码。用户能够通过搜索，找到带有搜索关键字的文章，实现了组合查询、精确查询和分类查询。用户也可以查看自己的评论、发帖、收藏文章和个人信息。

网站的设计与实现使用了Python+Flask+MysqL的web建设技术，并且使用HTML和CSS/DIV技术使网站页面更具灵活性。主要实现了用户的注册登录、文章分类搜索、个人信息、历史发布等10个功能模块。

                                                                                                    2、网站结构设计

父模板统一布局：(1) 头部导航条   (2) 中间主显示区域布局  (3) 底部导航条

1. 注册、登录、注销功能
2. 发布、列表显示
3. 详情页
4. 评论、列表显示
5. 个人中心
6. 搜索、条件组合搜索
7. 文章分类与显示
8. 点赞、收藏
9.  修改密码、头像、上传头像
10. 推荐文章

                                                                                                  3、模块详细设计

1、首页关键代码untitled.py文件

 

1、首页

首页是作为父模板，内容主要有导航栏，在更新其他页面的时候，导航栏保持不变。导航栏包括：首页，发布信息，搜索栏，登录，注册等。

2、注册、登录

在发布信息需要用户的注册和登录，如用户为登录，进入发布信息页面则会跳转登录页面。

3、发布信息

在用户登录后，即可发布信息。

4、搜索功能

通过输入关键字，可以通过精确查询搜索所有发过的信息，包括标题，内容，和评论。

5、个人中心

个人中心根据session的ID进入，里面展示了用户发表的信息，用户收藏和评论的文章，以及用户的个人信息。

 

from flask import Flask, render_template, request, redirect, url_for, session
from flask_sqlalchemy import SQLAlchemy
import config
from functools import wraps
from datetime import datetime
from sqlalchemy import or_, and_
from werkzeug.security import generate_password_hash, check_password_hash

app = Flask(__name__)  # 创建Flask对象
app.config.from_object(config)  # 关联config.py文件进来
db = SQLAlchemy(app)  # 建立和数据库的关系映射


class User(db.Model):  # 创建类User
    __tablename__ = 'user'  # 类对应的表名user
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)  # autoincrement自增长
    username = db.Column(db.String(20), nullable=False)  # nullable是否为空
    _password = db.Column(db.String(200), nullable=False)  # 密码加密内部使用
    nickname = db.Column(db.String(20), nullable=True)

    @property  # 定义函数，需要用属性时可以用函数代替
    def password(self):  # 密码加密外部使用
        return self._password

    @password.setter
    def password(self, row_password):  # 密码进来时进行加密,generate_password_hash是一个密码加盐哈希函数，生成的哈希值可通过check_password_hash()进行验证。
        self._password = generate_password_hash(row_password)

    def check_password(self, row_password):  # check_password_hash函数用于验证经过generate_password_hash哈希的密码。若密码匹配，则返回真，否则返回假。
        result = check_password_hash(self._password, row_password)
        return result


class Fabu(db.Model):   # 问答
    __tablename__ = 'fabu'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(100), nullable=False)
    detail = db.Column(db.Text, nullable=False)
    leixing = db.Column(db.String(20), nullable=True)
    creat_time = db.Column(db.DateTime, default=datetime.now)  # 提交时间会自己赋值
    author_id = db.Column(db.Integer, db.ForeignKey('user.id'))  # 数据类型是db.Integer，db.ForeignKey参数指定外键是哪个表中哪个id
    author = db.relationship('User', backref=db.backref('fabu'))  # 建立关联，其author属性将返回与问答相关联的用户实例，相当于数据库中的表连接
    # 第一个参数表明这个关系的另一端是哪个类，第二个参数backref，将向User类中添加一个fabu属性，从而定义反向关系，这一属性可访问Fabu类，获取的是模型对象
    yuedu = db.Column(db.Integer, nullable=False)


class Comment(db.Model):   # 评论
    __tablename__ = 'comment'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    fabu_id = db.Column(db.Integer, db.ForeignKey('fabu.id'))
    creat_time = db.Column(db.DateTime, default=datetime.now)
    detail = db.Column(db.Text, nullable=False)
    fabu = db.relationship('Fabu',
                           backref=db.backref('comments', order_by=creat_time.desc))  # order_by=creat_time.desc按时间降序
    author = db.relationship('User', backref=db.backref('comments'))


class Shoucang(db.Model):   # 收藏
    __tablename__ = 'shoucang'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    fabu_id = db.Column(db.Integer, db.ForeignKey('fabu.id'))
    fabu = db.relationship('Fabu', backref=db.backref('shoucangs'))
    author = db.relationship('User', backref=db.backref('shoucangs'))


class Dianzang(db.Model):   # 点赞
    __tablename__ = 'dianzang'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    fabu_id = db.Column(db.Integer, db.ForeignKey('fabu.id'))
    fabu = db.relationship('Fabu', backref=db.backref('dianzangs'))
    author = db.relationship('User', backref=db.backref('dianzangs'))


db.create_all()  # 测试是否连接成功

'''
# 插入功能
user = User(username='15',password='12')
db.session.add(user)
db.session.commit()

# 查询功能
user=User.query.filter(User.username=="15").first()
print(user.username,user.password)

# 修改功能
user=User.query.filter(User.username=="15").first()
user.password='888'
db.session.commit()

# 删除功能
user=User.query.filter(User.username=="15").first()
db.session.delete(user)
db.session.commit()
'''


# session会话连接
# filter()过滤器
# route制定路径和函数之间的关系
# def定义一个变量


# 跳转首页。
@app.route('/')
def daohang():
    pl = request.args.get('pl')   # 接收顺序排列的关键词，接收不到就按时间排列
    if pl == '按热度':
        context = {
            'fabus': Fabu.query.order_by('-yuedu').all(),
            'author': User.query.all(),
            'ydfabu': Fabu.query.filter(Fabu.yuedu > 5).all()  # 当发布的文章阅读量大于多少时取出这些文章，显示在首页的推荐文章
            # order_by('-creat_time')按时间降序排列，Fabu.query.all()查出了Fabu类的所有元组
        }
        return render_template('daohang.html', **context)
    else:
        context = {
            'fabus': Fabu.query.order_by('-creat_time').all(),
            'author': User.query.all(),
            'ydfabu': Fabu.query.filter(Fabu.yuedu > 5).all()  # 当发布的文章阅读量大于多少时取出这些文章，显示在首页的推荐文章
            # order_by('-creat_time')按时间降序排列，Fabu.query.all()查出了Fabu类的所有元组
        }
        return render_template('daohang.html', **context)


# 跳转测试。
@app.route('/lin/')
def lin():
    return 'lin'


# 跳转登陆。
@app.route('/denglu/', methods=['GET', 'POST'])  # methods定义它有两种请求方式
def denglu():
    if request.method == 'GET':
        return render_template('denglu.html')
    else:
        username = request.form.get('user')  # post请求模式，安排对象接收数据
        password = request.form.get('pass')
        user = User.query.filter(User.username == username).first()  # 作查询，并判断
        if user:  # 判断用户名
            if user.check_password(password):  # 判断密码
                session['user'] = username  # 利用session添加传回来的值username
                session['user_id'] = user.id
                session.permanent = True  # 设置session过期的时间
                return redirect(url_for('daohang'))
            else:
                return u'用户密码错误'
        else:
            return u'用户不存在,请先注册'



# 跳转密码修改页。
@app.route('/password_update/<user_id>')
def password_update(user_id):
    users = User.query.filter(User.id == user_id).first()  # 查询出要修改密码的该用户
    return render_template('password_update.html', users=users)



# 跳转修改密码后接受数据。
@app.route('/password_update1/', methods=['POST'])
def password_update1():
    username = request.form.get('username')  # 接收username的值，知道要修改的是哪个用户
    password = request.form.get('password')
    users = User.query.filter(User.username == username).first()  # 查询出要修改用户的整条信息
    users.password = password  # 执行修改
    db.session.commit()
    return redirect(url_for('yonghu', username_id=users.id, tag='1'))


@app.context_processor  # 上下文处理器，定义变量然后在所有模板中都可以调用，类似idea中的model
def mycontext():
    user = session.get('user')
    user_id = session.get('user_id')
    if user:
        return {'sessionusername': user, 'sessionuserid': user_id}  # 包装到username,在所有html模板中可调用
    else:
        return {}  # 返回空字典，因为返回结果必须是dict


# 跳转注销。
@app.route('/logout')
def logout():
    session.clear()  # 注销时删除所有session
    return redirect(url_for('daohang'))


# 跳转注册。
@app.route('/zhuce/', methods=['GET', 'POST'])  # methods定义它有两种请求方式,因为它在表单的请求是post，类似我们在idea中的sava请求模式
def zhuce():
    if request.method == 'GET':
        return render_template('zhuce.html')
    else:
        username = request.form.get('user')  # post请求模式，安排对象接收数据
        password = request.form.get('pass')
        nickname = request.form.get('nickname')
        user = User.query.filter(User.username == username).first()  # 作查询，并判断
        if user:
            return u'该用户已存在'
        else:
            user = User(username=username, password=password, nickname=nickname)  # 将对象接收的数据赋到User类中,即存到数据库
            db.session.add(user)  # 执行操作
            db.session.commit()
            return redirect(url_for('denglu'))  # redirect重定向


# 跳转某页面之前先进行登录。定义decorator可以增强函数功能,装饰器本身是函数，入参是函数，返回值也是函数
def loginFirst(fabu):
    @wraps(fabu)  # 加上wraps，它可以保留原有函数的__name__,docstring
    def wrapper(*args, **kwargs):  # 定义wrapper函数将其返回，用*args, **kwargs把原函数的参数进行传递
        if session.get('user'):  # 只有经过登陆，session才能记住并get到值
            return fabu(*args, **kwargs)
        else:
            return redirect(url_for('denglu'))

    return wrapper


# 跳转图片。
@app.route('/tupian/')
def tupian():
    return render_template('tupian.html')


# 跳转发布。
@app.route('/fabu/', methods=['GET', 'POST'])  # methods定义它有两种请求方式
@loginFirst  # 将decorator定义的增强函数放在待增强函数定义的上面
def fabu():
    if request.method == 'GET':
        return render_template('fabu.html')
    else:
        title = request.form.get('title')  # post请求模式，安排对象接收数据
        detail = request.form.get('detail')
        leixing = request.form.get('leixing')
        yuedu = 0
        author_id = User.query.filter(
            User.username == session.get('user')).first().id  # 将session get到的user进行查询并取出id放到外键author_id中
        fabu = Fabu(title=title, detail=detail, author_id=author_id, leixing=leixing,
                    yuedu=yuedu)  # 将对象接收的数据赋到Fabu类中,即存到数据库
        db.session.add(fabu)  # 执行操作
        db.session.commit()  # 提交到数据库
        return redirect(url_for('daohang'))  # redirect重定向


# 跳转发布详情
@app.route('/fabuview/<fabu_id>')  # 和idea的update一样，将id带到控制器
def fabuview(fabu_id):
    yes = Shoucang.query.filter(  # yes用在用户详情页判断是否已收藏的按钮
        and_(
            Shoucang.author_id == session.get('user_id'), Shoucang.fabu_id == fabu_id
        )
    ).first()
    dzyes = Dianzang.query.filter(  # dzyes用在用户详情页判断是否已点赞的按钮
        and_(
            Dianzang.author_id == session.get('user_id'), Dianzang.fabu_id == fabu_id
        )
    ).first()
    fa = Fabu.query.filter(Fabu.id == fabu_id).first()  # 根据主页带回来的id查询出整条元组记录，丢进fa
    comments = Comment.query.filter(Comment.fabu_id == fabu_id).all()  # 根据带回来的Fabu的id在Comment查询出所有评论
    fa.yuedu = fa.yuedu + 1  # 定义浏览功能，每次进去详情页，浏览次数加1
    db.session.commit()
    return render_template('fabuview.html', fa=fa, comments=comments, yes=yes,
                           dzyes=dzyes)  # 把值fa丢进键fa，在fabuview.html页面调用




# 跳转首页搜索

@app.route('/search/')
def search():
    sousuo = request.args.get('sousuo')  # args获取关键字,区别form
    author = User.query.all()
    ydfabu = Fabu.query.filter(Fabu.yuedu > 5).all()
    fabus = Fabu.query.filter(
        or_(  # 两种查询条件
            Fabu.title.contains(sousuo),  # contains模糊查
            Fabu.detail.contains(sousuo)
        )
    ).order_by('-creat_time')
    return render_template('daohang.html', fabus=fabus, author=author, ydfabu=ydfabu)  # fabus要和原首页数据模型一样


# 跳转高级分类查询
@app.route('/fenlei/')
def fenlei():
    fenlei = request.args.get('fenlei')  # args获取关键字,区别form
    author = User.query.all()
    ydfabu = Fabu.query.filter(Fabu.yuedu > 5).all()
    fenlei_fabus = Fabu.query.filter(
        or_(  # 两种查询条件
            Fabu.title.contains(fenlei),  # contains模糊查
            Fabu.leixing.contains(fenlei),
            Fabu.creat_time.contains(fenlei)
        )
    ).order_by('-creat_time')
    return render_template('daohang.html', fabus=fenlei_fabus, author=author, ydfabu=ydfabu)  # fabus要和原首页数据模型一样


# 跳转文章收藏
@app.route('/shoucang/', methods=['POST'])
@loginFirst
def shoucang():
    scfabu_id = request.form.get('scfabu_id')
    scuser_id = request.form.get('scuser_id')
    shoucang = Shoucang(fabu_id=scfabu_id, author_id=scuser_id)
    db.session.add(shoucang)  # 执行操作
    db.session.commit()  # 提交到数据库
    return redirect(url_for('fabuview', fabu_id=scfabu_id))


# 跳转文章点赞
@app.route('/dianzang/', methods=['POST'])
@loginFirst
def dianzang():
    dzfabu_id = request.form.get('dzfabu_id')
    dzuser_id = request.form.get('dzuser_id')
    dianzang = Dianzang(fabu_id=dzfabu_id, author_id=dzuser_id)
    db.session.add(dianzang)  # 执行操作
    db.session.commit()  # 提交到数据库
    return redirect(url_for('fabuview', fabu_id=dzfabu_id))


if __name__ == '__main__':
    app.run(debug=True)

　2、数据库设计config.py文件

import os
DEBUG = True

SECRET_KEY = os.urandom(24)

DIALECT = 'mysql'
DRIVER = 'mysqldb'
USERNAME = 'root'
PASSWORD = 'ROOT'
HOST = '127.0.0.1'
PORT = '3306'
DATABASE = 'mis_db'

# 配置和数据库的连接信息
SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:@localhost/mis_db?charset=utf8'
SQLALCHEMY_TRACK_MODIFICATIONS = False

　　                                                                                                4、成品展示

注册页面

登陆页面

发布信息页面

修改密码页面