选课系统

选课系统

一、需求分析

# 项目需求如下
'''
角色:学校、学生、课程、讲师
要求:
　　1. 创建北京、上海 2 所学校
　　2. 创建linux , python , go 3个课程 ， linux\py在北京开，go在上海开
　　3. 管理员创建学校 ，老师，课程
　　4. 学校包含学校名称，地址等属性
　　5. 学生注册登录后，可以选择学校，选择课程，查看成绩
　　6. 学生只能选择一所学校，从校区中选择一门课程，课程绑定给学生。
　　7. 老师登录后，可以查看教授课程，选择想要教授的课程，查看课程下的学生，修改学生成绩等

最终分为以下视图和功能：
学生视图
        1、注册
        2、登录
        3、选择校区
        4、选择课程
        5、查看成绩

老师视图
        1、登录
        2、查看教授课程
        3、选择教授课程
        4、查看课程下学生
        5、修改学生成绩

管理视图，创建讲师， 创建班级，创建课程
        1、注册
        2、登录
        3、创建学校
        4、创建老师
        5、创建课程
'''

二、程序的框架设计

'''
程序的架构一共分为三层:

    - 1.用户视图层

    - 2.接口层

    - 3.数据层
         - models ---> 用于把数据封装在对象中
         - db_handler ---> 把对象通过pickle的形式进行存储
'''

三、程序的目录结构

'''
conf放置配置信息setting
core：放置用户层视图
db：数据操作层py文件和以文件形式保存的数据，通过pickle把数据序列化保存到文件里。
interface：放置接口相关信息，有管理员接口，老师接口，学校接口，学生接口和公共接口
lib：放置公共方法


用户功能层：src下：
                src：主视图，
                admin：管理员视图，
                student：学生视图
                teacher：老师视图

接口层：interface下：
                  admin_interface管理员的接口
                  common_interface公共的接口
                  school_interface学校的接口
                  student_interface学生的接口
                  teacher_interface老师的接口
数据层：db目录下：
                db_handler，文件操作相关的方法
                models：各种类及类方法的定义

其它目录：admin，course，school，student，teacher是自动生成的目录，用来存放数据信息

start.py启动文件

总共分三个视图：
    管理员视图：
        def admin_register():
            pass
        def admin_login():
            pass
        def creat_school():
            pass
        def creat_teacher():
            pass
        def creat_course():
            pass
    老师视图：
        def teacher_login():
            pass
        def check_course():
            pass
        def choose_course():
            pass
        def check_student():
            pass
        def modify_score():
            pass
    学生视图：
        def student_register():
            pass
        def student_login():
            pass
        def choose_school():
            pass
        def choose_course():
            pass
        def check_score():
            pass
'''

四、具体功能分析

选课系统总复习:
   -  用户视图层
        与用户交互
        - 管理员
        - 学生
        - 老师

   - 接口层
        处理业务逻辑
        - admin_interface
        - student_interface
        - teacher_interface
        - common_interface

   - 数据层
        - models
            存放一个个的类

        - db_handler
            - pickle
                通过pickle存取对象

功能分类

    注意: 为所有登录、注册意外的功能添加装饰器，用作用户认证

    - 管理员功能
        1.注册
            - 让用户输入用户名与密码，传给注册接口
            - 注册接口接收到用户名与密码
            - 调用models的类的select方法获取对象
            - 判断对象是否存在，若存在，则返回用户已存在
            - 若用户不存在，则调用models的类的save方法保存对象
            注意: 密码md5加密

        2.登录
            - 让用户输入用户名与密码，传给登录接口
            - 登录接口接收到用户名与密码
            - 调用models的类的select方法获取对象
            - 判断对象是否存在，若不存在，则返回用户不存在
            - 若用户存在，则判断用户输入的密码是否与对象中的密码一样
            - 若一样则返回登录成功，否则返回密码错误。
            - 用户视图层，记录当前用户登录状态

        3.创建学校
            - 让用户输入学校名称与学校地址
            - 把学校名称与学校地址发送给接口层
            - 再接口层调用调用models的类的select方法获取学校对象
            - 判断学校是否存在，若存在，返回学校已存在，退出
            - 若学校不存在，则获取管理员对象，让管理员调用创建学校功能
            - 管理员的创建学校方法中，调用School类触发__init__,self.save()保存对象

        4.创建课程
            - 调用获取所有学校接口获取所有学校，若没有退出功能
            - 若有，则打印所有学校名称与编号， 让用户选择学校编号
            - 对用户输入的选择数据进行限制
            - 获取学校名称，输入需要创建的课程名称
            - 调用接口，把学校名称、创建的课程传给创建课程接口
            - 先获取学校对象，查看当前输入的课程是否存在学校对象的course_list中
            - 若存在，则返回，课程已存在，重新输入课程名称
            - 若不存在，则让管理员对象创建课程，得先获取管理员对象
            - 通过管理员对象调用创建课程方法，把课程名称与学校传给该方法
            - 调用Course课程类，触发__init__创建课程对象，并保存文件
            - 让课程对象去添加学校，课程对象.school = 学校名绑定学校
            - 获取学校对象，学校对象调用add_course方法，并把该课程添加到学校course_list中
            - 再保存即可

        5.创建老师
            - 让用户输入老师名称，调用创建老师接口
            - 先获取老师对象，判断老师是否存在
            - 若存在，则返回
            - 若不存在则创建老师,把管理员对现象获取出来
            - 让管理员对象来调用创建老师方法
            - 调用Teacher老师类，触发__init__，调用save方法保存老师对象。
            注意: 密码md5加密

    - 学生功能
        1.学生注册
            与管理员一样

        2.学生登录
            与管理员一样

        3.选择学校
            - 调用获取学校接口，获取所有学校
   

五、项目开发-选课系统

start.py -----项目启动文件

import os
import sys
from core import src

BASE_PATH = os.path.dirname(__file__)
# 添加环境变量
sys.path.append(BASE_PATH)

if __name__ == '__main__':
    src.run()

randme.txt -----项目说明文件

1.需求分析

# 项目需求如下
'''

对象角色:
    管理员对象、学生对象、老师对象、课程对象、学校对象

    - 至少需要创建5个类.

要求:
    # 管理员模块 ---》 注册、登录、创建学校、创建课程、创建老师
　　1. 创建北京、上海 2 所学校  ---》 创建学校 （学校名称与学校地址）

    学校课程---》 [创建课程1, 创建课程2, ...]
　　2. 创建linux , python13 , go 3个课程 ， linux\py在北京开，go在上海开 ---> 创建课程（课程名称，绑定学校）

　　3. 管理员创建学校 ，课程  ，老师  ---》 创建老师， （老师名字，老师密码）

　　4. 学校包含学校名称，地址等属性

    # 学生模块 ---》 注册、登录、选择学校、选择课程、查看成绩
　　5. 学生注册登录后，可以选择学校，选择课程，查看成绩

　　6. 学生只能选择一所学校，可以从校区中选择多门课程，课程绑定给学生。
        [创建课程1, 创建课程2, ...]  <----- 学生选择学校中的一门课程， 学生课程列表[课程1, 课程2]

    # 老师模块 ---》 登录、查看教授课程、选择教授课程、查看课程下的学生、修改学生成绩
　　7. 老师登录后，可以查看教授课程，选择想要教授的课程，查看课程下的学生，修改学生成绩等



视图和功能：

    - 总视图: src.py

        让用户先进入总视图，然后再通过选择的编号 进入相应的视图。

        - 学生视图
                1、注册
                2、登录
                3、选择校区
                4、选择课程
                5、查看成绩

        - 老师视图
                1、登录
                2、查看教授课程
                3、选择教授课程
                4、查看课程下学生
                5、修改学生成绩

        - 管理视图，创建讲师， 创建班级，创建课程
                1、注册
                2、登录
                3、创建学校
                4、创建老师
                5、创建课程
'''


2.项目的架构设计
    - 三层架构
        - 用户视图层
            - 接收用户输入的内容
            - 接收接口层返回的数据，并展示给用户

        - 接口层
            - 业务逻辑的处理
            - 将处理完的结果返回的用户视图层 ↑
            - 产生的数据: ↓

        - 数据处理层
            - 数据的存取
            - 存: 拿到接口层产生的数据进行保存
            - 查: 将数据返回给接口层  ↑



3.分任务开发
4.测试
5.上线



两条路:
    1.下周一考试，今天不讲完
        - 考试 管理员

    2.下周一自习，下周二考试。
        - 考试  整个选课系统


注意: 写完所有功能，务必删除所有文件后，重新测试，以免报错!

conf-------setting.py----项目系统配置文件

import os


DABA_PATH = os.path.dirname(os.path.dirname(__file__))
DB_PATH = os.path.join(DABA_PATH, 'db')

core-----src.py ---- 主视图

from core import admin_view, student_view, teacher_view


def run():
    while True:
        print('---欢迎进入辜氏家族选课---')
        print('''
            1.管理员
            2.学生
            3.老师
            q.退出            
        ''')
        dict = {'1': admin_view.run,
                '2': student_view.run,
                '3': teacher_view.run}
        choice = input('请选择你功能：').strip()
        if choice == 'q':
            break
        elif choice in dict:
            dict[choice]()
        else:
            print('输入不正确！重新来过')
            continue

core-----admin_view.py ---- 管理员视图

from interface import admin_interface
from interface import common_interface
from lib import common

admin_info = {'user': None}


def register():
    '''
    # 注册
    :return:
    '''
    while True:
        print('---管理员注册---')
        user_name = input('输入用户名:').strip()
        user_pwd = input('输入密码:').strip()
        pwd_d = input('确认密码:').strip()
        if not user_pwd == pwd_d:
            print('密码不一致')
            continue
        # 调用注册接口
        flag, msg = admin_interface.register_interface(user_name, user_pwd)
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


def login():
    '''
    # 登录
    :return:
    '''
    while True:
        print('---登录页面---')
        user_name = input('输入用户名:').strip()
        user_pwd = input('输入密码:').strip()
        # 调用登录接口
        flag, msg = common_interface.login_interface(user_name, user_pwd, 'admin')
        if flag:
            print(msg)
            admin_info['user'] = user_name
            break
        else:
            print(msg)
            continue


# 创建学校
@common.login_auth('admin')
def create_school():
    '''
    # 创建学校
    :return:
    '''
    while True:
        print('---创建学校页面---')
        school_name = input('输入学校名称:').strip()
        school_addr = input('输入学校地址:').strip()
        # 调用创建学校接口
        flag, msg = admin_interface.create_school_interface(
            school_name, school_addr, admin_info['user']
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


# 创建老师
@common.login_auth('admin')
def create_teacher():
    '''
    # 创建老师
    :return:
    '''
    while True:
        print('---创建老师---')
        teacher_name = input('输入老师名称：').strip()
        flag ,msg = admin_interface.create_teacher_interface(
            teacher_name, admin_info['user']
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


# 创建课程
@common.login_auth('admin')
def create_course():
    '''
    # 创建课程
    1.打印学校列表,按照路径来
    2.选择学校
    3.调用接口
    :return:
    '''
    while True:
        print('---创建课程---')
        # 获取所有学校
        school_list = common_interface.check_school_interface()
        if not school_list:
            print('还没有学校，请返回先创建学校再来！')
            break
        # 循环打印,用枚举
        for index, school_name in enumerate(school_list):
            print(index, school_name)

        choice = input('请先择学校：').strip()

        if not choice.isdigit():
            print('请输入编号!')
            continue
        choice = int(choice)

        if choice not in range(len(school_list)):
            print('请输入正确的范围！')
            continue
        school_name = school_list[choice]

        # 选择学校后，输入课程的名称
        course_name = input('输入课程名称：').strip()
        # 调用管理员中创建课程接口
        flag, msg = admin_interface.create_course_interface(
            school_name, course_name, admin_info['user']
        )
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


def run():
    while True:
        print('你已进入管理员！')
        print('''
            1.注册
            2.登录
            3.创建学校
            4.创建老师
            5.创建课程
            q.返回   
        ''')
        dict = {'1': register,
                '2': login,
                '3': create_school,
                '4': create_teacher,
                '5': create_course}
        choice = input('选择功能：').strip()
        if choice == 'q':
            break
        elif not choice in dict:
            print('输入不正确！重新来过')
            continue
        dict[choice]()

core-----student_view.py---学生视图

from interface import student_interface
from interface import common_interface
from lib import common


student_info = {'user': None}


def register():
    while True:
        print('---学生注册---')
        user_name = input('输入用户名:').strip()
        user_pwd = input('输入密码:').strip()
        pwd_d = input('确认密码:').strip()
        if not user_pwd == pwd_d:
            print('密码不一致')
            continue
        # 调用注册接口
        flag, msg = student_interface.register_interface(user_name, user_pwd)
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


def login():
    '''
    # 登录
    :return:
    '''
    while True:
        print('---登录页面---')
        user_name = input('输入用户名:').strip()
        user_pwd = input('输入密码:').strip()
        # 调用登录接口
        flag, msg = common_interface.login_interface(user_name, user_pwd, 'student')
        if flag:
            print(msg)
            student_info['user'] = user_name
            break
        else:
            print(msg)
            continue


# 选择学校
@common.login_auth('student')
def choose_school():
    while True:
        print('---选择学校---')
        # 先打印学校列表
        school_list = common_interface.check_school_interface()
        if not school_list:
            print('学校还没开，请等待！')
            break
        # 循环打印
        for index, school_name in enumerate(school_list):
            print(index, school_name)

        choice = input('请输入选择的学校编号(q.退出)：').strip()
        if choice == 'q':
            break
        if not choice.isdigit():
            print('输入不规范，重新输入！')
            continue
        choice = int(choice)
        # 判断范围
        if choice not in range(len(school_list)):
            print('输入的不在范围，重新输入！')
            continue
        school_name = school_list[choice]

        # 调用学生中的选择学校接口
        flag, msg = student_interface.choose_school_interface(school_name, student_info['user'])
        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


# 选择课程
@common.login_auth('student')
def choose_course():
    while True:
        print('---选择课程---')
        # 获取当前对象的学校中所有的课程
        flag, course_list = student_interface.select_course_list(student_info['user'])

        # 判断返回值是否为空--->看看学校课程列表有没有课程
        if not flag:
            print(course_list)
            break
        # 打印课程列表，让用户选择
        for index, course_name in enumerate(course_list):
            print(index, course_name)
        choice = input('请输入选择的课程编号(q.退出)：').strip()

        if choice == 'q':
            break
        if not choice.isdigit():
            print('输入不规范，不是数字！')
            continue
        choice = int(choice)
        if choice not in range(len(course_list)):
            print('输入不规范，不在范围！')
            continue

        course_name = course_list[choice]
        # 调用学生选择课程接口
        flag, msg = student_interface.choose_course(course_name, student_info['user'])

        if flag:
            print(msg)
            break
        else:
            print(msg)
            continue


# 查看分数
@common.login_auth('student')
def check_score():
    while True:
        print('---查看分数---')
        score_dict = student_interface.check_score(student_info['user'])
        print(score_dict)
        break


def run():
    while True:
        print('你已进入学生端！')
        print('''
            1.注册
            2.登录
            3.选择校区
            4.选择课程
            5.查看成绩
            q.返回   
        ''')
        dict = {'1': register,
                '2': login,
                '3': choose_school,
                '4': choose_course,
                '5': check_score}
        choice = input('选择功能：').strip()
        if choice == 'q':
            break
        elif not choice in dict:
            print('输入不正确！重新来过')
            continue
        dict[choice]()

core-----teacher_view.py ----老师视图

from lib import common
from interface import common_interface
from interface import teacher_interface


teacher_info = {'user': None}

# 登录
def login():
    '''
    # 登录
    :return:
    '''
    while True:
        print('---登录页面---')
        user_name = input('输入用户名:').strip()
        user_pwd = input('输入密码:').strip()
        # 调用登录接口
        flag, msg = common_interface.login_interface(user_name, user_pwd, 'teacher')
        if flag:
            print(msg)
            teacher_info['user'] = user_name
            break
        else:
            print(msg)
            continue


# 选择教授课程
@common.login_auth('teacher')
def choose_course():
    while True:
        print('---选择课程---')
        # 获取学校---->循环打印学校--->选择学校--->打印学校中的课程列表
        # --->让老师选择--->添加到老师对象的课程列表中
        school_list = common_interface.check_school_interface()
        # 判断学校是否存在
        if not school_list:
            print('还没有学校可以选择，请联系管理员！')
            break
        # 循环打印
        for index, school_name in enumerate(school_list):
            print(index, school_name)

        # 选择
        choice = input('请输入学校编号:').strip()
        if not choice.isdigit():
            print('请规范选择，输入数字！')
            continue
        choice = int(choice)

        if choice not in range(len(school_list)):
            print('请规范选择，不在范围！')
            continue
        # 1.拿到学校名称
        school_name = school_list[choice]

        # 通过学校名称，获取学校下的所有课程列表
        flag, course_list = common_interface.check_course_interface(school_name)

        if not flag:
            print(course_list)
            break
        # 循环打印
        for index, course_name in enumerate(course_list):
            print(index, course_name)

        choice = input('请输入课程编号:').strip()
        if not choice.isdigit():
            print('输入不规范，请输入数字！')
            continue
        choice = int(choice)
        if choice not in range(len(course_list)):
            print('输入不规范，不在范围！')
            continue

        # 2.拿到课程名称
        course_name = course_list[choice]

        # 调用选择教授课程接口
        flag, msg = teacher_interface.choose_course_interface(
            course_name, teacher_info['user'])

        if flag:
            print(msg)
            break
        else:
            print(msg)


# 查看教授课程
@common.login_auth('teacher')
def check_course():
    while True:
        print('---教授课程---')
        flag, course_list = teacher_interface.check_course(teacher_info['user'])
        if flag:
            print(course_list)
            break
        else:
            print(course_list)
            break


# 查看课程下学生
@common.login_auth('teacher')
def check_course_student():
    while True:
        print('---查看课程下学生---')
        # 打印老师的课程列表--->选择课程--->查看课程下的学生
        flag, course_list = teacher_interface.check_course(teacher_info['user'])
        if not flag:
            print(course_list)
            break
        # 打印课程列表
        for index, course_name in enumerate(course_list):
            print(index, course_name)
        choice = input('请输入课程编号: ').strip()
        if not choice.isdigit():
            continue
        choice = int(choice)

        if choice not in range(len(course_list)):
            continue
        # 1.获取了课程名称
        course_name = course_list[choice]

        # 调用接口，获取课程下的学生列表
        flag, student_list = teacher_interface.check_student(
            course_name, teacher_info['user']
        )
        if flag:
            print(student_list)
            break

        else:
            print(student_list)
            break


# 修改学生成绩
@common.login_auth('teacher')
def change_score():
    while True:
        # 1.获取老师中所有的课程，并选择
        flag, course_list_or_msg = teacher_interface.check_course(
            teacher_info['user'])

        if not flag:
            print(course_list_or_msg)
            break

        # 2.通过课程查看课程中所有的学生
        for index, course_name in enumerate(course_list_or_msg):
            print(index, course_name)

        choice = input('请输入课程编号: ').strip()
        if not choice.isdigit():
            print('输入不规范，请输入数字！')
            continue

        choice = int(choice)

        if choice not in range(len(course_list_or_msg)):
            print('输入不规范，不在范围！')
            continue

        course_name = course_list_or_msg[choice]

        # 3.调用查看课程中所有学生接口
        flag, student_list = teacher_interface.check_student(
            course_name, teacher_info['user']
        )

        if not flag:
            print(student_list)
            break

        # 4.先循环打印所有的学生，并选择学生编号，获取学生名字
        for index, student_name in enumerate(student_list):
            print(index, student_name)

        choice2 = input('请输入学生编号: ').strip()
        if not choice2.isdigit():
            print('输入不规范，请输入数字！')
            continue

        choice2 = int(choice2)

        if choice2 not in range(len(student_list)):
            print('输入不规范，不在范围！')
            continue

        # 获取学生名字
        student_name = student_list[choice2]

        # 让老师输入修改课程的分数
        score = input('请输入修改的分数: ').strip()

        # 课后作业1: 校验修改的分数是否是数字

        score = int(score)

        # 课后作业2: 校验输入的成绩是否 > 100分

        # 5.调用修改学生分数接口
        flag, msg = teacher_interface.change_score(
            student_name, course_name, score, teacher_info['user']
        )

        if flag:
            print(msg)
            break



def run():
    while True:
        print('你已进入老师端！')
        print('''
            1、登录
            2、选择教授课程
            3、查看教授课程
            4、查看课程下学生
            5、修改学生成绩
            q.返回   
        ''')
        dict = {'1': login,
                '2': choose_course,
                '3': check_course,
                '4': check_course_student,
                '5': change_score}
        choice = input('选择功能：').strip()
        if choice == 'q':
            break
        elif not choice in dict:
            print('输入不正确！重新来过')
            continue
        dict[choice]()

db-----db_hanler.py----数据处理

import os
from conf import setting
import pickle


# 保存
def save(obj):

    # 获取对象的名字,就是要保存的目录的名字
    cls_name = obj.__class__.__name__
    # 拼接当前对象保存目录的路径
    dir_path = os.path.join(setting.DB_PATH, cls_name)

    # 判断目录是否存在,不存在则创建
    if not os.path.exists(dir_path):
        os.mkdir(dir_path)
    # 拼接目录下的文件绝对路径
    user_path = os.path.join(dir_path, obj.name)

    # 写入
    with open(user_path, 'wb')as f:
        pickle.dump(obj, f)
        f.flush()


# 查看
def select(cls, name):
    # admin_obj.__class__ --> Admin.__name__ ----> 'Admin'
    # 获取对象的名字,比如teacher,admin,student
    cls_name = cls.__name__
    # 拼接路径
    dir_path = os.path.join(setting.DB_PATH, cls_name)

    # 若不存在，则创建目录
    if not os.path.exists(dir_path):
        os.mkdir(dir_path)

    # 拼接当前用户文件的绝对路径
    user_path = os.path.join(dir_path, name)

    # 若存在，则查找，不存在返回NONE
    if os.path.exists(user_path):
        with open(user_path, 'rb')as f:
            obj = pickle.load(f)
            return obj

db-----models.py----类属性

from db import db_handler
from lib import common


# 主父
class Base():
    # 保存
    def save_obj(self):
        db_handler.save(self)

    # 直接用类来调用，所有用类绑定
    @classmethod
    def select_obj(cls, name):
        obj = db_handler.select(cls, name)
        return obj


# 管理员
class Admin(Base):
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = common.md5(pwd)

    # 管理员创建学校方法
    def create_school(self, school_name, school_addr):
        school_obj = School(school_name, school_addr)
        school_obj.save_obj()

    # 创建老师
    def create_teacher(self, teacher_name, pwd):
        teacher_obj = Teacher(teacher_name, pwd)
        teacher_obj.save_obj()

    # 创建课程
    def create_course(self, school_name, course_name):
        course_obj = Course(school_name, course_name)
        course_obj.save_obj()
        # 把课程添加到学校中
        school_obj = School.select_obj(school_name)
        school_obj.course_list.append(course_name)
        school_obj.save_obj()


# 学校类
class School(Base):
    def __init__(self, school_name, school_addr):
        self.name = school_name
        self.addr = school_addr
        # 此学校的课程列表
        self.course_list = []


# 老师类
class Teacher(Base):
    def __init__(self, teacher_name, pwd):
        self.name = teacher_name
        self.pwd = common.md5(pwd)
        self.course_list = []

    # 添加课程
    def add_course(self, course_name):
        self.course_list.append(course_name)
        self.save_obj()

    # 查看课程下的所有学生方法
    def check_course_student(self, course_name):
        # 获取课程对象
        course_obj = Course.select_obj(course_name)
        # 获取学生列表
        student_list = course_obj.student_list
        return student_list

    # 老师修改分数方法
    def change_score(self, student_name, course_name, score):
        # 1.获取学生对象
        student_obj = Student.select_obj(student_name)

        # 2.直接修改学生score属性
        student_obj.score[course_name] = score
        student_obj.save_obj()


# 课程类
class Course(Base):
    def __init__(self, school_name, course_name):
        self.school = school_name
        self.name = course_name
        # 此门课的学生列表
        self.student_list = []

    def add_student(self,student_name):
        self.student_list.append(student_name)
        self.save_obj()


class Student(Base):
    def __init__(self, student_name, pwd):
        self.name = student_name
        self.pwd = common.md5(pwd)
        self.school = None
        self.course_list = []
        self.score = {}
        self.save_obj()

    # 学生添加学校
    def add_school(self, school_name):
        self.school = school_name
        self.save_obj()

     # 学生添加课程
    def add_course(self, course_name):
        self.course_list.append(course_name)
        self.score[course_name] = 0
        self.save_obj()

        # 课程对象添加学生
        course_obj = Course.select_obj(course_name)
        course_obj.add_student(self.name)

interface-----admin_interface.py---管理员接口

from db import models


# 注册
def register_interface(user_name, user_pwd):
    # 通过user_name 判断用户对象是否存在
    obj = models.Admin.select_obj(user_name)
    # 如果对象不存在则创建
    if not obj:
        admin_obj = models.Admin(user_name, user_pwd)
        admin_obj.save_obj()
        return True, f'用户【{user_name}】注册成功！'

    return False, '用户已存在！'


# 创建学校
def create_school_interface(school_name, school_addr, admin_name):
    # 判断学校是否存在，不存则创建
    school_obj = models.Admin.select_obj(school_name)

    if school_obj:
        return False, '学校已存在！'

    # 获取管理员对象，调用管理员的 创建学校的方法
    admin_obj = models.Admin.select_obj(admin_name)
    admin_obj.create_school(school_name, school_addr)
    return True, f'【{school_name}】学校创建成功！'


# 创建老师
def create_teacher_interface(teacher_name, admin_name):

    pwd = '123'  # 默认密码

    # 判断老师是否存在，不存在就创建
    teacher_obj = models.Teacher.select_obj(teacher_name)

    if teacher_obj:
        return False, '老师已存在！'

    # 由管理员创建
    admin_obj = models.Admin.select_obj(admin_name)
    admin_obj.create_teacher(teacher_name, pwd)
    return True, f'【{teacher_name}】老师创建成功！'


# 创建课程
def create_course_interface(school_name, course_name, admin_name):
    # 1.获取学校对象 ，判断课程是否存在学校对象课程列表中
    school_obj = models.School.select_obj(school_name)
    if course_name in school_obj.course_list:
        return False, '课程已存在'

    # 2.获取管理员对象，调用管理员对象中的创建课程方法
    admin_obj = models.Admin.select_obj(admin_name)
    admin_obj.create_course(school_name, course_name)
    return True, f'【{course_name}】课程创建成功！'

interface-----student_interface.py-----学生接口

from db import models


# 注册
def register_interface(user_name, user_pwd):
    # 通过user_name 判断用户对象是否存在
    obj = models.Student.select_obj(user_name)
    # 如果对象不存在则创建
    if not obj:
        admin_obj = models.Student(user_name, user_pwd)
        admin_obj.save_obj()
        return True, f'用户【{user_name}】注册成功！'

    return False, '用户已存在！'


# 选择学校接口
def choose_school_interface(school_name, student_name):
    # 获取学生对象
    student_obj = models.Student.select_obj(student_name)

    # 判断学生是否已经选择了学校
    if student_obj.school:
        return False, '已经选择过学校了'
    # 若不存在，则调用学生对象中的选择学校的方法，添加学校
    student_obj.add_school(school_name)
    return True, f'【{school_name}】学校添加成功!'


# 获取当前学生中学校的所有课程
def select_course_list(student_name):
    # 获取当前学生对象 ----》看学生是否已经选择学校
    student_obj = models.Student.select_obj(student_name)
    school_name = student_obj.school

    # 判断学校是否存在
    if not school_name:
        return False, '请先选择学校！'

    # 拿到了学校名字--->获取学校对象--->拿到学校对象中的课程列表
    school_obj = models.School.select_obj(school_name)
    course_list = school_obj.course_list
    # 判断课程列表是否存在
    if course_list:
        return True, course_list
    else:
        return False, '该学校还没有课程！'


# 选择课程
def choose_course(course_name, student_name):
    # 获取学生对象--->拿到学生中的课程列表
    student_obj = models.Student.select_obj(student_name)
    course_list = student_obj.course_list

    # 判断当前选择的课程，是否已经存在课程列表中
    if course_name in course_list:
        return False, '该课程已经存在！'

    # 若不存在，则添加到课程列表中，让学生对象调用添加课程方法
    student_obj.add_course(course_name)
    return True, f'【{course_name}】课程添加成功！'


# 查看分数
def check_score(student_name):
    # 获取学生对象
    student_obj = models.Student.select_obj(student_name)
    # 拿到分数字典
    score_dict = student_obj.score
    return score_dict

interface-----teacher_interface.py-----老师接口

from db import models


# 老师选择课程
def choose_course_interface(course_name, teacher_name):
    # 获取老师对象--->获取老师对象中的已教学的课程列表
    teacher_obj = models.Teacher.select_obj(teacher_name)
    teacher_course_list = teacher_obj.course_list
    # 判断该课程是否已经存在，不存在则调用添加课程方法添加
    if course_name in teacher_course_list:
        return False, '该课程已经存在'
    # 调用接口，添加课程
    teacher_obj.add_course(course_name)
    return True, f'添加【{course_name}】课程成功！'


# 查看老师下的所有课程
def check_course(teacher_name):
    # 获取老师对象
    teacher_obj = models.Teacher.select_obj(teacher_name)
    # 获取老师对象中的课程列表---老师已教授
    teacher_course_list = teacher_obj.course_list

    if not teacher_course_list:
        return False, '该老师还没有选择教授课程！'
    return True, teacher_course_list


# 查看课程下的所有学生
def check_student(course_name, teacher_name):
    # 获取老师对象
    teacher_obj = models.Teacher.select_obj(teacher_name)
    # 调用查看学生的方法
    student_list = teacher_obj.check_course_student(course_name)

    if not student_list:
        return False, '课程中没有学生'

    return True, student_list


# 老师修改分数接口
def change_score(student_name, course_name, score, teacher_name):
    # 1.获取老师对象
    teacher_obj = models.Teacher.select_obj(teacher_name)

    # 2.通过老师对象，调用修改分数方法
    teacher_obj.change_score(
        # 学生名字传入，为了获取学生对象，并修改学生中的课程成绩
        student_name, course_name, score,
    )

    return True, f'【{student_name}】学生分数修改成功, 课程[{course_name}]分数为: [{score}]'

interface-----common_interface-----公共接口

from db import models
from lib import common
import os
from conf import setting


# 公共登录
def login_interface(user_name, user_pwd, role):
    obj = None
    # 校验身份
    if role == 'admin':
        # 判断对象是否存在
        obj = models.Admin.select_obj(user_name)
        user_pwd = common.md5(user_pwd)
        # 如果不存在，失败，存在就校验密码

    # 校验身份
    elif role == 'student':
        # 判断对象是否存在
        obj = models.Student.select_obj(user_name)
        user_pwd = common.md5(user_pwd)
        # 如果不存在，失败，存在就校验密码

    # 校验身份
    elif role == 'teacher':
        # 判断对象是否存在
        obj = models.Teacher.select_obj(user_name)
        user_pwd = common.md5(user_pwd)
        # 如果不存在，失败，存在就校验密码

    if not obj:
        return False, '用户不存在，从新输入！'

    if obj.pwd == user_pwd:
        return True, '登录成功！'

    else:
        return False, '密码错误！'


# 获取所有学校
def check_school_interface():
    # 拼接存方学校文件的路径
    school_dir = os.path.join(setting.DB_PATH, 'School')

    if os.path.exists(school_dir):
        # 获取文件下的所有文件的名字
        school_list = os.listdir(school_dir)
        return school_list


# 获取学校下的所有课程
def check_course_interface(school_name):
    school_obj = models.School.select_obj(school_name)

    # 通过拿到的学校对象，拿到学校对象中的所有课程的列表
    course_list = school_obj.course_list

    # 判断列表是否为空
    if course_list:
        return True, course_list
    return False, '学校中还没有课程，请联系管理员！'

lib-----conmon.py----公共功能

import hashlib
from functools import wraps

def md5(pwd):
    md5 = hashlib.md5()
    val = '辜氏家族终极密码'
    md5.update(val.encode('utf-8'))
    md5.update(pwd.encode('utf-8'))
    return md5.hexdigest()



def login_auth(role):
    def outter(func):
        @wraps(func)
        def inner(*args, **kwargs):
            while True:
                if role == 'admin':
                    from core import admin_view
                    user = admin_view.admin_info['user']
                    if user:
                        return func(*args, **kwargs)
                    else:
                        print('请先登录')
                        break
                elif role == 'student':
                    from core import student_view
                    user = student_view.student_info['user']
                    if user:
                        return func(*args, **kwargs)
                    else:
                        print('请先登录')
                        break
                elif role == 'teacher':
                    from core import teacher_view
                    user = teacher_view.teacher_info['user']
                    if user:
                        return func(*args, **kwargs)
                    else:
                        print('请先登录')
                        break
        return inner
    return outter