阶段测评'选课系统'

'''
角色:学校、学生、课程、讲师
要求:
　　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
'''

具体项目程序

bin/start

import os
import sys
from core import src

sys.path.append(
    os.path.dirname(__file__)
)


print([i ** i for i in range(3)])

if __name__ == '__main__':

    src.run()

conf/settings

# 配置储存文件的地址

import os

DATE_PATH = os.path.dirname(os.path.dirname(__file__))
# 拼接db地址
DB_PATH = os.path.join(DATE_PATH, 'db')

core/src/admin_view/student_view/teacher_view

# src
"""
总视图
"""
from core import admin_view
from core import student_view
from core import teacher_view

func_dic = {
    "1": admin_view.view,
    "2": student_view.view,
    "3": teacher_view.view,
}


def run():
    while True:
        print('''
        =====欢迎来到老男孩选课系统=====
        1.管理员界面
        2.学生界面
        3.老师界面
        4.退出界面(q)
        ''')
        choice = input('请输入相对应编号进入操作界面').strip()
        if choice == 'q':
            break
        if choice not in func_dic:
            print('编号输入有误,请重新输入')
            continue
        func_dic.get(choice)()


        
        
#admin_view
'''
管理员视图
'''
from interface import admin_interface
from interface import common_interface
from lib import common

admin_info = {
    'user_name': None
}


# 注册功能
def register():
    while True:
        username = input('请输入管理员用户名:').strip()
        password = input('请输入管理员密码:').strip()
        re_password = input('请确认管理员密码:').strip()  # 校验两次密码是否一致
        if password == re_password:
            # 调用管理员注册接口
            flag, msg = admin_interface.register_interface(username, password)
            if flag:
                print(msg)
                choice = input('输入q退出注册或任意字符继续注册').strip()
                if choice == 'q':
                    break
                else:
                    print('继续注册')
                continue
            else:
                print(msg)
        else:
            print('两次密码不一致')

# 登陆功能
def login():
    while True:
        username = input('请输入管理员用户名:').strip()
        password = input('请输入管理员密码:').strip()

        # 调用公共登陆接口
        flag, msg = common_interface.login_interface(username, password, 'admin')
        if flag:
            admin_info['user_name'] = username
            print(msg)
            break
        else:
            print(msg)
            choice = input('q退出或任意字符重新登陆').strip()
            if choice == 'q':
                break
            else:
                print('重新登陆')

# 转公共方法设置公共登陆认证


# 创建学校功能
@common.login_auth('admin')
def creat_school():
    while True:
        # 管理员输入 学校名称 与 学校地址
        school_name = input('请输入学校名称:').strip()
        school_addr = input('请输入学校地址:').strip()

        # 调用学校接口,并传入 学校名称和 学校地址, 以及管理员民称(管理员名称是为了获取管理员对象
        # 并调用管理员类的创建学校方法)

        flag, msg = admin_interface.creat_school_interface(
            school_name, school_addr, admin_info.get('user_name'))

        if flag:
            print(msg)
            bank = input('请输入q返回界面或任意字符继续创建:').strip()
            if bank == 'q':
                break
            continue
        else:
            print(msg)


# 创建课程功能
@common.login_auth('admin')
def creat_course():
    while True:
        # 先获取所有的学校,让管理员选择
        # 判断是否有学校
        school_list = common_interface.check_school_interface()
        if not school_list:
            print('没有可选择的学校,请先创建学')
            choice = input('输入y创建学校,任意键退出:').strip()
            if choice == 'y':
                return creat_school
            else:
                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.creat_course(school_name, course_name, admin_info.get('user_name'))
        if flag:
            print(msg)
            choose = input('输入y继续添加课程,任意字符退出:').strip()
            if choose == 'y':
                continue
            break
        else:
            print(msg)


# 创建老师功能
@common.login_auth('admin')
def creat_teacher():
    while True:
        teacher_name = input('请输入老师名称:').strip()
        # 调用创建接口,保存老师信息
        flag, msg = admin_interface.create_teacher_interface(
            teacher_name, admin_info.get('user_name'))
        if flag:
            print(msg)
            bank = input('请输入q返回界面或任意字符继续添加老师:')
            if bank == 'q':
                break
            continue
        else:
            print(msg)

func_dic = {
    '1': register,
    '2': login,
    '3': creat_school,
    '4': creat_course,
    '5': creat_teacher,
}


def view():
    while True:
        print('''
         =====欢迎来到管理员系统=====
         1、注册
         2、登录
         3、创建学校
         4、创建课程
         5、创建老师
         6、退出界面(q)
         ''')
        choice = input('请输入相对应编号进入操作界面').strip()
        if choice == 'q':
            break
        if choice not in func_dic:
            print('编号输入有误,请重新输入')
            continue
        func_dic.get(choice)()
        

        
# student_view
'''
学生视图
'''
from interface import common_interface

from interface import student_interface
from lib import common

student_info = {
    'user_name': None
}


# 注册功能
def register():
    while True:
        username = input('请输入学生用户名:').strip()
        password = input('请输入学生密码:').strip()
        re_password = input('请确认学生密码:').strip()  # 校验两次密码是否一致
        if password == re_password:
            # 调用学生注册接口
            flag, msg = student_interface.register_interface(username, password)
            if flag:
                print(msg)
                choose = input('继续输入请按y,任意键退出').strip()
                if choose == 'y':
                    continue
                break
            else:
                print(msg)
        else:
            print('两次密码不一致')


# 登陆功能
def login():
    while True:
        # 先输入用户名和密码
        username = input('请输入用户名: ').strip()
        password = input('请输入登陆密码: ').strip()
        # 调用公共登陆接口
        flag, msg = common_interface.login_interface(username, password, 'student')
        if flag:
            student_info['user_name'] = username
            print(msg)
            break
        else:
            print(msg)
            print('不想登陆可以选择q退出')
            choose = input('选择q退出')
            if choose == 'q':
                break
            else:
                print('请重新输入用户名和密码')


# 选择学校功能
@common.login_auth('student')
def choose_school():
    while True:
        # 获取所有学校的一个列表,并且打印出来
        school_list = common_interface.check_school_interface()
        # 判断是否有学校,没有则退出
        if not school_list:
            print('没有可选择的学校,请先创建学校')
            break
        # 有则通过enumerate打印出序号和名字
        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.get('user_name'))
        if flag:
            print(msg)
            break
        else:
            print(msg)


# 选择课程功能
@common.login_auth('student')
def choose_course():
    while True:
        # 通过获取课程接口,获取当前对象的 学校中 所有课程列表或 没有课程的返回信息
        flag, course_list_or_msg = student_interface.get_all_course_interface(student_info.get('user_name'))
        if not flag:
            print(course_list_or_msg)
            break
        # 如果有课程,选择课程名称,通过enumerate
        for index, course_name in enumerate(course_list_or_msg):
            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_or_msg)):
            print('输入有误,请重新输入')
            continue
        course_name = course_list_or_msg[choice]

        # 调用学生选择课程接口
        flag, msg = student_interface.choose_courser_interface(
            course_name, student_info.get('user_name'))
        if flag:
            print(msg)
            break
        else:
            print(msg)


# 查看分数功能
@common.login_auth('student')
def check_score():
    score_dic = student_interface.check_score_interface(student_info.get('user_name'))
    print(score_dic)


func_dic = {
    '1': register,
    '2': login,
    '3': choose_school,
    '4': choose_course,
    '5': check_score,
}


def view():
    while True:
        print('''
         =====欢迎来到学员系统=====
         1、注册
         2、登录
         3、选择校区
         4、选择课程
         5、查看成绩
         6、退出界面(q)
         ''')
        choice = input('请输入相对应编号进入操作界面').strip()
        if choice == 'q':
            break
        if choice not in func_dic:
            print('编号输入有误,请重新输入')
            continue
        func_dic.get(choice)()

        
# teacher_view
'''
老师视图
'''
'''
老师视图
'''
from interface import teacher_interface
from lib import common
from interface import common_interface

teacher_info = {
    'user_name': None
}


# 登陆功能

def login():
    while True:
        # 先输入用户名和密码
        username = input('请输入用户名: ').strip()
        password = input('请输入登陆密码: ').strip()
        # 调用公共登陆接口
        flag, msg = common_interface.login_interface(username, password, 'teacher')
        if flag:
            teacher_info['user_name'] = username
            print(msg)
            break
        else:
            print(msg)
            print('不想登陆可以选择q退出')
            choose = input('选择q退出')
            if choose == 'q':
                break
            else:
                print('请重新输入用户名和密码')


# 查看教授课的课程
@common.login_auth('teacher')
def check_course():
    while True:
        # 调用查看课程列表接口
        flag, course_list_or_msg = teacher_interface.check_course_interface(teacher_info['user_name'])
        if flag:
            print(course_list_or_msg)
            break
        else:
            print(course_list_or_msg)
            break


# 选择教授的课程
@common.login_auth('teacher')
def choose_course():
    while True:
        # 先获取所有的学校,选择学校
        # 获取所有学校的一个列表,并且打印出来
        school_list = common_interface.check_school_interface()
        # 判断是否有学校,没有则退出
        if not school_list:
            print('没有可选择的学校,请先创建学校')
            break
        # 有则通过enumerate打印出序号和名字
        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, course_list_or_msg = common_interface.check_course_from_school(school_name)
        if not flag:
            print(course_list_or_msg)
            break
        # 如果有课程,选择课程名称,通过enumerate
        for index, course_name in enumerate(course_list_or_msg):
            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_or_msg)):
            print('输入有误,请重新输入')
            continue
        course_name = course_list_or_msg[choice]
        # 调用选择教授课程的接口
        flag, msg = teacher_interface.choose_course_interface(
            course_name, teacher_info.get('user_name'))
        if flag:
            print(msg)
            break
        else:
            print(msg)


# 查看教授课程下的学生
@common.login_auth('teacher')
def check_student():
    while True:
        # 获取老师中所有的课程
        flag, course_list_or_msg = teacher_interface.check_course_interface(
            teacher_info.get('user_name'))
        if not flag:
            print(course_list_or_msg)
            break
        # 通过课程查看课程下所有的学生
        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]

        # 调用查看课程中所有学生的接口
        flag, student_list_or_msg = teacher_interface.check_student_interface(
            course_name, teacher_info.get('user_name'))
        if flag:
            print(student_list_or_msg)
            break
        else:
            print(student_list_or_msg)
            break


# 修改成绩功能
@common.login_auth('teacher')
def change_score():
    while True:
        # 获取老师中所有的课程
        flag, course_list_or_msg = teacher_interface.check_course_interface(
            teacher_info.get('user_name'))
        if not flag:
            print(course_list_or_msg)
            break
        # 通过课程查看课程下所有的学生
        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]
        # 调用查看课程中所有学生的接口
        flag, student_list_or_msg = teacher_interface.check_student_interface(
            course_name, teacher_info.get('user_name'))
        if not flag:
            print(student_list_or_msg)
            break
        # 循环打印所有的学生, 并选择学生编号,获取学生名字
        for index, student_name in enumerate(student_list_or_msg):
            print(index, student_name)

        choice2 = input('请输入学生编号: ').strip()
        if not choice2.isdigit():
            print('输入格式有误')
            continue
        choice2 = int(choice2)
        if choice2 not in range(len(student_list_or_msg)):
            continue

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

        # 让老师输入修改课程的分数
        score = input('请输入修改分数').strip()
        if not score.isdigit():
            print('输入格式有误')
            continue
        # 调用修改学生分数的接口
        flag, msg = teacher_interface.change_score_interface(
            student_name, course_name, score, teacher_info.get('user_name'))
        if flag:
            print(msg)
            break


func_dic = {
    '1': login,
    '2': check_course,
    '3': choose_course,
    '4': check_student,
    '5': change_score,
}


def view():
    while True:
        print('''
         =====欢迎来到教师系统=====
          1、登陆功能         
          2、查看教授课程
          3、选择教授课程
          4、查看课程下学生
          5、修改学生成绩
          6、退出界面(q)
         ''')
        choice = input('请输入相对应编号进入操作界面').strip()
        if choice == 'q':
            break
        if choice not in func_dic:
            print('编号输入有误,请重新输入')
            continue
        func_dic.get(choice)()
        

interface/ student_interface/teacher_interface/admin_interface

/common_interface

# admin_interface
'''
管理员接口
'''
from db import models

'''
atm是在接口创建字典,而选课系统是通过创建管理员对象,让db_handler保存
'''
# 管理员接口


# 管理员注册接口
def register_interface(username, password):
    # 查看该管理员用户 对象 是否已经存在
    # 调用db模块中的models来查看对象obj or None
    obj = models.Admin.select_obj_by_name(username)
    if not obj:
        # 若查不到对象,开始创建对象并保留数据
        admin_obj = models.Admin(username, password)  # 会触发Admin中的__init__
        admin_obj.save_obj()
        return True, f'用户{username}注册成功!'

    return False, '用户已存在'


# 管理员创建学校接口
def creat_school_interface(school_name, school_addr, admin_name):
    # 检验学校是否存在,若存在则返回"学校已经存在"
    school_obj = models.School.select_obj_by_name(school_name)
    if school_obj:
        return False, '学校已存在'

    # 若不存在,获取管理员对象来创建
    admin_obj = models.Admin.select_obj_by_name(admin_name)

    # 通过管理员对象来调用创建学校的方法
    admin_obj.creat_school(school_name, school_addr)
    return True, '学校创建成功'

# 管理员创建课程接口
def creat_course(school_name, course_name, admin_name):
    # 先获取学校对象,判断用户输入的课程是否已经存在学校对象
    school_obj = models.School.select_obj_by_name(school_name)
    if course_name in school_obj.course_list:
        return False, '该课程已经存在'  # 需要在课程类中提前加一个空列表

    # 如果没有,获取管理员对象,通过管理员对象调用创建课程的方法
    admin_obj = models.Admin.select_obj_by_name(admin_name)
    # 创建一个创建课程的方法
    admin_obj.creat_course(school_name, course_name)
    return True, '该课程创建成功'


# 创建老师接口:老师密码默认为123
def create_teacher_interface(teacher_name, admin_name, pwd='123'):
    # 检验老师是否存在, 通过老师对象查看
    teacher_obj = models.Teacher.select_obj_by_name(teacher_name)
    if teacher_obj:
        return False, '该老师已经存在,不需要重复添加'
    # 若不存在该老师, 调用管理员对象创建老师
    admin_obj = models.Admin.select_obj_by_name(admin_name)
    admin_obj.create_teacher(teacher_name, pwd)
    return True, '老师信息创建成功'








# student_interface
'''
学生接口
'''
from db import models
# 学生注册接口
def register_interface(username, password):
    # 首先查看学生对象是否存在
    obj = models.Student.select_obj_by_name(username)

    if not obj:
        student_obj = models.Student(username, password)
        student_obj.save_obj()
        return True, f"用户{username}注册成功"
    return False, f"用户{username}已存在"

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

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


# 获取学生当前学校所有课程接口
def get_all_course_interface(student_name):
    # 获取学生对象
    student_obj = models.Student.select_obj_by_name(student_name)
    # 获取学校名字
    school_name = student_obj.school
    # 判断学生是否已经选择学校了
    if not school_name:
        return False, '请先选择学校'

    # 获取学校对象, 获取学校对象中的课程列表
    school_obj = models.School.select_obj_by_name(school_name)
    course_list = school_obj.course_list
    if course_list:
        return True, course_list
    else:
        return False, '学校中没有课程'


# 学生选择课程接口
def choose_courser_interface(course_name, student_name):
    # 获取学生对象, 获取学生课程列表
    student_obj = models.Student.select_obj_by_name(student_name)
    course_list = student_obj.course_list

    # 判断当前课程是否存在于 学生对象的课程列表中
    if course_name in course_list:
        return False, '该课程已经存在'
    # 若不存在,则添加到课程列表中, 调用学生对象添加课程方法, (注意添加初始分数)
    student_obj.add_course(course_name)
    return True, '添加课程成功'

# 学生查看分数接口
def check_score_interface(student_name):
    # 获取学生对象
    student_obj = models.Student.select_obj_by_name(student_name)
    return student_obj.score





# teacher_interface
'''
teacher
'''
from db import models
# 查看老师名下所有课程接口
def check_course_interface(teacher_name):
    # 获取老师对象
    teacher_obj = models.Teacher.select_obj_by_name(teacher_name)
    # 由老师对象调用查看课程方法
    course_list = teacher_obj.check_all_course()
    if not course_list:
        return False, f'{teacher_name}老师没有课程'
    return True, course_list


# 老师选择课程接口
def choose_course_interface(course_name, teacher_name):
    # 获取老师对象
    taecher_obj = models.Teacher.select_obj_by_name(teacher_name)
    teacher_course_list= taecher_obj.course_list
    # 判断该课程是否存在
    if course_name in teacher_course_list:
        return False, '该课程已经存在'

    # 若不存在,则将课程添加进去
    taecher_obj.add_course(course_name)
    return True, f'{course_name}已添加成功'


# 老师查看课程名下所有学生的接口
def check_student_interface(course_name, teacher_name):
    # 获取老师对象
    teacher_obj = models.Teacher.select_obj_by_name(teacher_name)
    # 通过老师对象调取查看所有学生方法
    student_list = teacher_obj.cheak_student_from_course(course_name)
    if not student_list:
        return False, f'{course_name}中没有学生'
    else:
        return True, student_list

# 老师修改分数接口
def change_score_interface(
            student_name, course_name, score, teacher_name):
    # 获取老师对象
    teacher_obj = models.Teacher.select_obj_by_name(teacher_name)
    # 通过老师对象来调用修改分数方法
    teacher_obj.change_score(student_name, course_name, score)
    return True, f'{student_name}的成绩已修改为{score}'




#common_interface
'''
公共接口
'''
# 查看学校中所有课程的接口
def check_course_from_school(school_name):
    # 获取学校对象
    school_obj = models.School.select_obj_by_name(school_name)

    # 通过学校对象,调用查看学校所有课程的方法,返回一个列表
    course_list = school_obj.check_all_course()
    if course_list:
        return True, course_list
    else:
        return False, f'{school_name}没有课程!'

db/handler/models

# handler
'''
数据的保存和取用
'''
from conf import settings
import pickle
import os
# 保存数据
def save(obj):  # 将models的对象接收并保存
    # 保存对象
    # 拼接文件保存路径, 为了避免名字有重复,将当前的类当作文件夹, 以对象的名称作为文件名
    # admin_obj.__class__ 可以获得对象的Admin类名,--->Admin.__name__可以获得'Admin'类名字符串
    cls_name = obj.__class__.__name__
    # 再获取类名所在文件夹地址(可以放在配置文件中)
    cls_path = os.path.join(settings.DB_PATH, cls_name)
    # 判断cls_path 是否存在
    if not os.path.exists(cls_path):
        # 不存在直接创建
        os.mkdir(cls_path)

    # 若存在,拼接用户绝对路径
    user_path = os.path.join(cls_path, obj.name)

    # 将obj对象写入pickle文件中
    with open(user_path, 'wb') as f:
        pickle.dump(obj, f)
        f.flush()


# 查看数据
def select(cls, name):
    # 保存对象
    # 拼接文件保存路径, 为了避免名字有重复,将当前的类当作文件夹, 以对象的名称作为文件名
    # admin_obj.__class__ 可以获得对象的Admin类名,--->Admin.__name__可以获得'Admin'类名字符串
    cls_name = cls.__name__
    # 再获取类名所在文件夹地址(可以放在配置文件中)
    cls_path = os.path.join(settings.DB_PATH, cls_name)
    # 判断cls_path 是否存在
    if not os.path.exists(cls_path):
        # 不存在直接创建
        os.mkdir(cls_path)

    # 若存在,拼接用户绝对路径
    user_path = os.path.join(cls_path, name)
    # 若文件路径存在则查找对象
    if os.path.exists(user_path):
        # 将文件对象读取出来
        with open(user_path, 'rb') as f:
            obj = pickle.load(f)
            return obj


        
        
#models
'''
类库
'''
'''
存放一个个的类:

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

所有类的父类:
    - Class Base:

    - 技能:
        - 保存数据
        - 查看数据

课程对象(课程类):
    - 特征（属性）:
        - 课程名字
        - 学校
        - 学生列表

    - 技能（方法）
        - 保存数据（课程）
        - 查看数据（课程）

        - 添加学校
            self.学校 = 上海校区

        - 添加学生
            self.学生列表.append(学生)


学生对象（学生类）:
    - class Student(Base):
        - 特征（属性）:
            - 名字
            - 密码
            - 学校
            - 课程列表
            - 分数字典: {'课程名字': 课程分数, '课程名字2': 课程分数,}

        - 技能（方法）
            - 保存数据（注册）:
                - 调用学生类，实例化得到一个学生对象，并将学生对象保存成pickle文件。

            - 查看数据（登录）：
                - 从pickle文件中读出相应的对象。

            - 选择校区
                学校 = oldboy

            - 选择课程
                self.课程列表.append(课程)

            - 查看成绩
                for line in self.分数字典:
                    print(line)


老师对象（老师类）:
    class Teacher(Base):
        - 特征（属性）:
            - 名字
            - 密码
            - 课程列表

        - 技能（方法）

            - 保存数据（老师）

            - 查看数据 (登录)

            - 查看教授课程
                self.课程列表

            - 选择教授课程
                课程列表.append(课程名字)

            - 查看课程下学生
                课程列表.课程---》 获取课程对象.学生列表

            - 修改学生成绩
                课程列表.课程----> 获取课程对象.学生列表.学生 ----> 获取学生对象.分数字典[课程]  = 100


管理员对象（管理员类）:
    - class Admin(Base):
        - 特征（属性）:
            - 名字
            - 密码

        - 技能（方法）
            - 保存数据 (注册)
                - 调用管理员类，实例化得到一个管理员对象，并将管理员对象保存成pickle文件。

            - 查看数据 (登录)

            - 创建学校
                - 调用学校类，实例化得到一个学校对象，并将学校对象保存成pickle文件。

            - 创建老师
                - 调用老师类，实例化得到一个老师对象，并将老师对象保存成pickle文件。

            - 创建课程
                - 调用课程类，实例化得到一个课程对象，并将课程对象保存成pickle文件。


学校对象（学校类）:
    - class School(Base):
        - 特征（属性）:
            - 学校名称
            - 学校地址
            - 课程列表
            -

        - 技能（方法）
            - 查看数据（学校）
            - 保存数据（学校）

            - 添加课程
                self.课程列表.append(课程)

'''
from db import db_handler


# 父类
class Base:

    # 保存 数据(对象) 的方法
    def save_obj(self):
        # 调用db _handler中的save将对象保存到pickle文件中
        db_handler.save(self)  # 将产生的对象传入db_handler中保存

    # 查看 通过传入名字查看数据(对象)的方法
    @classmethod
    def select_obj_by_name(cls, name):
        obj = db_handler.select(cls, name)

        return obj


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

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

    # 创建课程的方法
    def creat_course(self, school_name, course_name):
        # 调用课程类,创建课程对象
        Course(school_name, course_name)
        # 获取学校对象,为学校对象中的课程列表添加课程(一个学校有多个课程)
        school__obj = School.select_obj_by_name(school_name)
        school__obj.course_list.append(course_name)
        # 保存
        school__obj.save_obj()

    # 创建老师的方法
    def create_teacher(self, teacher_name, teacher_pwd):
        Teacher(teacher_name, teacher_pwd)


# 学生类
class Student(Base):
    def __init__(self, student_name, student_pwd):
        self.name = student_name
        self.pwd = student_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_by_name(course_name)
        # 调用添加学生的方法,将课程和学生绑定
        course_obj.add_student(self.name)


# 老师类
class Teacher(Base):
    def __init__(self, teacher_name, teacher_pwd):
        self.name = teacher_name
        self.pwd = teacher_pwd
        self.course_list = []  # 提前建一个空课程列表,老师允许有多门课程
        self.save_obj()

    # 老师查看所有课程的方法
    def check_all_course(self):
        return self.course_list

    # 老师添加课程的方法
    def add_course(self, course_name):
        self.course_list.append(course_name)
        self.save_obj()

    # 老师查看课程下所有学生的方法
    def cheak_student_from_course(self, course_name):
        # 获取课程对象
        course_obj = Course.select_obj_by_name(course_name)
        # 通过课程对象获取课程下学生列表
        student_list = course_obj.check_all_student()
        return student_list

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

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



# 学校类
class School(Base):
    def __init__(self, school_name, school_addr):
        self.name = school_name
        self.addr = school_addr
        self.course_list = []
        self.save_obj()

    # 查看所有课程的方法
    def check_all_course(self):
        return self.course_list


# 课程类
class Course(Base):
    '''
      - 课程名字
      - 学校
      - 学生列表
      '''

    def __init__(self, school_name, course_name):
        self.school_name = school_name
        self.name = course_name
        self.student_list = []
        self.save_obj()

    # 课程添加学生的方法
    def add_student(self, student_name):
        self.student_list.append(student_name)
        self.save_obj()

    # 课程对象获取所有学生方法
    def check_all_student(self):
        return self.student_list

lib/common

# 登陆认证装饰器, 以及权限认证

def login_auth(role):
    def outer(func):
        def inner(*args, **kwargs):
            # 权限认定
            if role == 'admin':
                from core import admin_view
                if admin_view.admin_info.get('user_name'):
                    res = func(*args, **kwargs)
                    return res
                else:
                    admin_view.login()
            elif role == 'student':
                from core import student_view
                if student_view.student_info.get('user_name'):

                    res = func(*args, **kwargs)
                    return res
                else:
                    student_view.login()
            elif role == 'teacher':
                from core import teacher_view
                if teacher_view.teacher_info.get('user_name'):
                    res = func(*args, **kwargs)
                    return res
                else:
                    teacher_view.login()
            else:
                print('该用户无此权限')

        return inner
    return outer