day09选课系统作业

作业需求:

角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程

7. 上面的操作产生的数据都通过pickle序列化保存到文件里

项目文件目录:

 conf

import os


BASE_PATH = os.path.dirname(
    os.path.dirname(__file__)
)

DB_PATH=os.path.join(
    BASE_PATH,'db'
)

core

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

admin_info = {
    'user': None
}

# 管理员注册
def register():
    while True:
        username = input('请输入用户名: ').strip()
        password = input('请输入密码: ').strip()
        re_password = input('请确认密码: ').strip()

        # 小的逻辑判断
        if password == re_password:
            # 调用接口层，管理员注册接口
            flag, msg = admin_interface.admin_register_interface(
                username, password
            )

            if flag:
                print(msg)
                break

            else:
                print(msg)

        else:
            print('两次密码不一致，请重新输入')


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

        # 1.调用管理员登录接口
        flag, msg = admin_interface.admin_login_interface(
            username, password
        )
        if flag:
            print(msg)
            # 记录当前用户登录状态
            # 可变类型不需要global
            admin_info['user'] = username
            break

        else:
            print(msg)


# 管理员创建学校
@common.auth('admin')
def create_school():
    while True:
        # 1.让用户输入学校的名称与地址
        school_name = input('请输入学校名称: ').strip()
        school_addr = input('请输入学校地址: ').strip()

        # 2.调用接口，保存学校
        flag, msg = admin_interface.create_school_interface(
            # 学校名、学校地址、创建学校的管理员
            school_name, school_addr, admin_info.get('user')
        )

        if flag:
            print(msg)
            break

        else:
            print(msg)


# 管理员创建课程
@common.auth('admin')
def create_course():
    while True:
        # 1.让管理员先选择学校
        # 1.1 调用接口，获取所有学校的名称并打印
        flag, school_list_or_msg = common_interface.get_all_school_interface()
        if not flag:
            print(school_list_or_msg)
            break

        for index, school_name in enumerate(school_list_or_msg):
            print(f'编号: {index}    学校名: {school_name}')

        choice = input('请输入学校编号: ').strip()

        if not choice.isdigit():
            print('请输入数字')
            continue

        choice = int(choice)

        if choice not in range(len(school_list_or_msg)):
            print('请输入正确编号!')
            continue

        # 获取选择后的学校名字
        school_name = school_list_or_msg[choice]

        # 2.选择学校后，再输入课程名称
        course_name = input('请输入需要创建的课程名称： ').strip()

        # 3.调用创建课程接口，让管理员去创建课程
        flag, msg = admin_interface.create_course_interface(
            # 传递学校的目的，是为了关联课程
            school_name, course_name, admin_info.get('user')
        )

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



# 管理员创建老师
@common.auth('admin')
def create_teacher():
    while True:
        # 1.让管理员输入创建的老师名字
        teacher_name = input('请输入老师的名字: ').strip()
        # 2.调用接口创建老师
        flag, msg = admin_interface.create_teacher_interface(
            teacher_name, admin_info.get('user'))

        if flag:
            print(msg)
            break

        else:
            print(msg)


func_dict = {
    '1': register,
    '2': login,
    '3': create_school,
    '4': create_course,
    '5': create_teacher,
}


# 管理员视图函数
def admin_view():
    while True:
        print('''
        - 1.注册
        - 2.登录
        - 3.创建学校
        - 4.创建课程
        - 5.创建讲师
        ''')

        choice = input('请输入功能编号: ').strip()

        if choice == 'q':
            admin_info['user'] = None
            break

        if choice not in func_dict:
            print('输入有误，请重新输入!')
            continue

        func_dict.get(choice)()

'''
用户视图层的主视图
'''


from core import admin
from core import student
from core import teacher


func_dic={
    '1': admin.admin_view,
    '2': student.student_view,
    '3': teacher.admin_view,

}


def run():
    while True:
        print(
            '''
            =======欢迎来到选课系统=======
                1.管理员功能
                2.学生功能
                3.老师功能
            ============end===========
            '''
        )

        choice=input('请输入功能编号:').strip()
        if choice == 'q':
            break

        if choice not in func_dic:
            print('输入有误,请重新输入!')
            continue

        func_dic.get(choice)()

'''学生视图'''
from lib import common
from interface import student_interface
from interface import common_interface

student_info = {'user': None}


# 学生注册
def register():
    while True:
        username = input('请输入用户名: ').strip()
        password = input('请输入密码: ').strip()
        re_password = input('请确认密码: ').strip()

        # 小的逻辑判断
        if password == re_password:

            # 调用接口层，学生注册接口
            flag, msg = student_interface.student_register_interface(
                username, password
            )

            if flag:
                print(msg)
                break

            else:
                print(msg)

        else:
            print('两次密码不一致，请重新输入')


# 学生登录
def login():
    while True:
        username = input('请输入用户名: ').strip()
        password = input('请输入密码: ').strip()

        # 1.调用管理员登录接口
        flag, msg = common_interface.login_interface(
            username, password, user_type='student'
        )
        if flag:
            print(msg)
            # 记录当前用户登录状态
            # 可变类型不需要global
            student_info['user'] = username
            break

        else:
            print(msg)


# 学生选择学校
@common.auth('student')
def choice_school():
    while True:
        # 1、获取所有学校，让学生选择
        flag, school_list = common_interface.get_all_school_interface()
        if not flag:
            print(school_list)
            break

        for index, school_name in enumerate(school_list):
            print(f'编号: {index}   学校名: {school_name}')

        # 2、让学生输入学校编号
        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]

        # 3、开始调用学生选择学校接口
        flag, msg = student_interface.add_school_interface(
            school_name, student_info.get('user'))

        if flag:
            print(msg)
            break

        else:
            print(msg)
            break


# 学生选择课程
@common.auth('student')
def choice_course():
    while True:
        # 1、先获取 "当前学生" 所在学校的课程列表
        flag, course_list = student_interface.get_course_list_interface(
            student_info.get('user')
        )
        if not flag:
            print(course_list)
            break

        # 2、打印课程列表，并让用户选择课程
        for index, school_name in enumerate(course_list):
            print(f'编号: {index}   学校名: {school_name}')

        # 2、让学生输入学校编号
        choice = input('请输入选择的学校编号: ').strip()
        if not choice.isdigit():
            print('输入有误')
            continue

        choice = int(choice)

        if choice not in range(len(course_list)):
            print('输入编号有误!')
            continue
        # 3、获取选择的课程名称
        course_name = course_list[choice]

        # 4、调用学生选择课程接口
        flag, msg = student_interface.add_course_interface(
            course_name, student_info.get('user')
        )

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


# 学生查看课程分数
@common.auth('student')
def check_score():
    # 1、直接调用查看分数接口
    score_dict = student_interface.check_score_interface(
        student_info.get('user')
    )

    if not score_dict:
        print('没有选择课程!')

    print(score_dict)


func_dict = {
    '1': register,
    '2': login,
    '3': choice_school,
    '4': choice_course,
    '5': check_score,
}


def student_view():
    while True:
        print('''
        - 1.注册
        - 2.登录功能
        - 3.选择校区
        - 4.选择课程
        - 5.查看分数
        ''')

        choice = input('请输入功能编号: ').strip()

        if choice == 'q':
            break

        if choice not in func_dict:
            print('输入有误，请重新输入!')
            continue

        func_dict.get(choice)()

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

teacher_info = {'user': None}


# 老师登录
def login():
    while True:
        username = input('请输入用户名: ').strip()
        password = input('请输入密码: ').strip()

        # 1.调用管理员登录接口
        flag, msg = common_interface.login_interface(
            username, password, user_type='teacher'
        )
        if flag:
            print(msg)
            # 记录当前用户登录状态
            # 可变类型不需要global
            teacher_info['user'] = username
            break

        else:
            print(msg)


# 查看教授课程
@common.auth('teacher')
def check_course():
    flag, course_list = teacher_interface.check_course_interface(
        teacher_info.get('user')
    )
    if flag:
        print(course_list)
    else:
        print(course_list)


# 选择教授课程
@common.auth('teacher')
def choose_course():
    while True:
        # 1、先打印所有学校，并选择
        flag, school_list = common_interface.get_all_school_interface()
        if not flag:
            print(school_list)
            break

        for index, school_name in enumerate(school_list):
            print(f'编号: {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]

        # 2、从选择的学校中获取所有的课程
        flag2, course_list = common_interface.get_course_in_school_interface(
            school_name
        )
        if not flag2:
            print(course_list)
            break

        for index2, course_name in enumerate(course_list):
            print(f'编号: {index2}   课程名: {course_name}')

        choice2 = input('请输入选择的课程编号: ').strip()

        if not choice2.isdigit():
            print('输入有误')
            continue

        choice2 = int(choice2)

        if choice2 not in range(len(course_list)):
            print('输入编号有误!')
            continue

        # 获取选择的课程名称
        course_name = course_list[choice2]

        # 3、调用选择教授课程接口，将该课程添加到老师课程列表中
        flag3, msg = teacher_interface.add_course_interface(
            course_name, teacher_info.get('user')
        )
        if flag3:
            print(msg)
            break
        else:
            print(msg)


# 查看课程下学生
@common.auth('teacher')
def check_stu_from_course():
    while True:
        # 1、调用获取当前老师下所有的课程接口
        flag, course_list = teacher_interface.check_course_interface(
            teacher_info.get('user')
        )
        if not flag:
            print(course_list)
            break

        # 2、打印所有课程，并让老师选择
        for index, course_name in enumerate(course_list):
            print(f'编号: {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

        # 3、获取选择的课程名称
        course_name = course_list[choice]

        # 4、利用当前课程名称获取所有学生
        flag2, student_list = teacher_interface.get_student_interface(
            course_name, teacher_info.get('user')
        )

        if flag2:
            print(student_list)
            break
        else:
            print(student_list)
            break


# 修改学生分数
@common.auth('teacher')
def change_score_from_student():
    '''
    # 1、先获取老师下所有的课程，并选择
    # 2、获取选择的课程下所有的学生，并选择修改的学生
    # 3、调用修改学生分数接口修改分数
    '''
    while True:
        # 1、调用获取当前老师下所有的课程接口
        flag, course_list = teacher_interface.check_course_interface(
            teacher_info.get('user')
        )
        if not flag:
            print(course_list)
            break

        # 2、打印所有课程，并让老师选择
        for index, course_name in enumerate(course_list):
            print(f'编号: {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

        # 3、获取选择的课程名称
        course_name = course_list[choice]

        # 4、利用当前课程名称获取所有学生
        flag2, student_list = teacher_interface.get_student_interface(
            course_name, teacher_info.get('user')
        )

        if not flag2:
            print(student_list)
            break

        # 5、打印所有学生让老师选择
        for index2, student_name in enumerate(student_list):
            print(f'编号：{index2}   学生名: {student_name}')

        choice2 = input('请输入学生编号： ').strip()

        choice2 = int(choice2)

        if choice2 not in range(len(student_list)):
            print('输入编号有误!')
            continue

        # 获取选择的课程名称
        student_name = student_list[choice2]

        # 老师输入需要修改的分数
        score = input('请输入需要修改的成绩:').strip()
        if not score.isdigit():
            continue

        score = int(score)

        # 6、调用修改学生分数接口修改分数
        flag3, msg = teacher_interface.change_score_interface(
            course_name, student_name,
            score, teacher_info.get('user')
        )

        if flag3:
            print(msg)
            break


func_dict = {
    '1': login,
    '2': check_course,
    '3': choose_course,
    '4': check_stu_from_course,
    '5': change_score_from_student,
}


def teacher_view():
    while True:
        print('''
        - 1.登录
        - 2.查看教授课程
        - 3.选择教授课程
        - 4.查看课程下学生
        - 5.修改学生分数
        ''')

        choice = input('请输入功能编号: ').strip()

        if choice == 'q':
            break

        if choice not in func_dict:
            print('输入有误，请重新输入!')
            continue

        func_dict.get(choice)()

db

存放管理员相关数据

存放课程相关数据

存放学校相关数据

存放老师相关数据

'''
用于保存对象与获取对象
'''
import os
import pickle
from conf import settings

# 保存数据
def save_data(obj):
    '''
    1.获取对象的保存文件夹路径
    以类名 当做 文件夹的名字
    obj.__class__: 获取当前对象的类
    obj.__class__.__name__: 获取类的名字
    '''
    class_name = obj.__class__.__name__
    user_dir_path = os.path.join(
        settings.DB_PATH, class_name
    )

    # 2.判断文件夹是否存在，不存在则创建文件夹
    if not os.path.exists(user_dir_path):
        os.mkdir(user_dir_path)

    # 3.拼接当前用户的pickle文件路径,， 以用户名作为文件名
    user_path = os.path.join(
        user_dir_path, obj.user  # 当前用户名字
    )

    # 4.打开文件，保存对象, 通过pickle
    with open(user_path, 'wb') as f:
        pickle.dump(obj, f)


# 查看数据
def select_data(cls, username):  # 类, username
    # 由cls类获取类名
    class_name = cls.__name__
    user_dir_path = os.path.join(
        settings.DB_PATH, class_name
    )

    # 2.判断文件夹是否存在，不存在则创建文件夹
    if not os.path.exists(user_dir_path):
        os.mkdir(user_dir_path)

    # 3.拼接当前用户的pickle文件路径,， 以用户名作为文件名
    user_path = os.path.join(
        user_dir_path, username  # 当前用户名字
    )

    # 4.判断文件如果存在，再打开，并返回，若不存在，则代表用户不存在
    if os.path.exists(user_path):
        # 5.打开文件，获取对象
        with open(user_path, 'rb') as f:
            obj = pickle.load(f)
            return obj

'''用于存放类的
学校类、学员类、课程类、讲师类、管理员类
'''
from db import db_handler


# 父类,让所有子类都继承 select 与 save方法
class Base:
    # 查看数据  ----> 登录、查看数据库
    @classmethod
    def select(cls, username):  # School, school_name
        # obj： 对象   or   None
        obj = db_handler.select_data(cls, username)
        return obj

    # 保存数据 ---> 注册、保存、更新数据
    def save(self):
        # 让db_handler中的save_data帮我保存对象数据
        db_handler.save_data(self)


# 管理员类
class Admin(Base):
    # 调用类的时候触发
    # username, password
    def __init__(self, user, pwd):
        # 给当前对象赋值
        self.user = user
        self.pwd = pwd

    # 创建学校
    def create_school(self, school_name, school_addr):
        '''该方法内部来调用学校类实例化的得到对象，并保存'''
        school_obj = School(school_name, school_addr)
        school_obj.save()

    # 创建课程
    def create_course(self, school_obj, course_name):
        # 1.调用课程类，实例化创建课程
        course_obj = Course(course_name)
        course_obj.save()
        # 2.获取当前学校对象，并将课程添加到课程列表中
        school_obj.course_list.append(course_name)
        # 3.更新学校数据
        school_obj.save()

    # 创建讲师
    def create_teacher(self, teacher_name, teacher_pwd):
        # 1.调用老师类，实例化的到老师对象，并保存
        teacher_obj = Teacher(teacher_name, teacher_pwd)
        teacher_obj.save()


# 学校类
class School(Base):
    def __init__(self, name, addr):
        # 必须写: self.user,
        # 因为db_handler里面的select_data统一规范
        self.user = name
        self.addr = addr
        # 课程列表: 每所学校都应该有相应的课程
        self.course_list = []


# 学生类
class Student(Base):

    def __init__(self, user, pwd):
        self.user = user
        self.pwd = pwd
        # 每个学生只能有一个校区
        self.school = None
        # 一个学生可以选择多门课程
        self.course_list = []
        # 学生课程分数
        self.score_dict = {}  # {"course_name": 0}

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

    # 学生添加课程方法
    def add_course(self, course_name):
        # 1、学生课程列表添加课程
        self.course_list.append(course_name)
        # 2、给学生选择的课程设置默认分数
        self.score_dict[course_name] = 0
        self.save()
        # 3、学生选择的课程对象，添加学生
        course_obj = Course.select(course_name)
        course_obj.student_list.append(
            self.user
        )
        course_obj.save()


# 课程类
class Course(Base):
    def __init__(self, course_name):
        self.user = course_name
        self.student_list = []


# 老师类
class Teacher(Base):
    def __init__(self, teacher_name, teacher_pwd):
        self.user = teacher_name
        # self.pwd需要统一
        self.pwd = teacher_pwd
        self.course_list_from_tea = []

    # 老师查看教授课程方法
    def show_course(self):
        return self.course_list_from_tea

    # 老师添加课程方法
    def add_course(self, course_name):
        self.course_list_from_tea.append(
            course_name
        )
        self.save()

    # 老师获取课程下学生方法
    def get_student(self, course_name):
        course_obj = Course.select(course_name)
        return course_obj.student_list

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

        # 2、再给学生对象中的课程修改分数
        student_obj.score_dict[course_name] = score
        student_obj.save()

interface

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


# 管理员注册接口
def admin_register_interface(username, password):
    # 1.判断用户是否存在
    # 调用Admin类中的，select方法，
    # 由该方法去调用db_handler中的select_data功能获取对象
    admin_obj = models.Admin.select(username)

    # 1.1) 若存在不允许注册，返回用户已存在给视图层
    if admin_obj:
        return False, '用户已存在!'

    # 1.2) 若不存在则允许注册，调用类实例化得到对象并保存
    admin_obj = models.Admin(username, password)
    # 对象调用save() 会将 admin_obj传给save方法
    admin_obj.save()

    return True, '注册成功!'


# 管理员登录接口
def admin_login_interface(username, password):
    # 1.判断用户是否存在
    admin_obj = models.Admin.select(username)

    # 2.若不存在，则证明用户不存在并返回给视图层
    if not admin_obj:
        return False, '用户名不存在!'

    # 3.若用户存在，则校验密码
    if password == admin_obj.pwd:
        return True, '登录成功! '
    else:
        return False, '密码错误!'


# 管理员创建学校接口
def create_school_interface(school_name, school_addr, admin_name):
    # 1.查看当前学校是否已存在
    # school_obj ---> 对象  or   None
    school_obj = models.School.select(school_name)

    # 2.若学校存在，则返回False告诉用户学校已存在
    if school_obj:
        return False, '学校已存在!'

    # 3.若不存在，则创建学校， 注意: （由管理员对象来创建）
    admin_obj = models.Admin.select(admin_name)
    # 由管理员来调用创建学校方法，并传入学校的名字与地址
    admin_obj.create_school(
        school_name, school_addr
    )

    # 4.返回创建学校成功给视图层
    return True, f'[{school_name}]学校创建成功!'


# 管理员创建课程接口
def create_course_interface(school_name, course_name, admin_name):
    # 1.查看课程是否存在
    # 1.1 先获取学校对象中的课程列表
    school_obj = models.School.select(school_name)
    # 1.2 判断当前课程是否存在课程列表中
    if course_name in school_obj.course_list:
        return False, '当前课程已存在!'

    # 1.2 若课程不存在，则创建课程， 由管理员来创建
    admin_obj = models.Admin.select(admin_name)
    admin_obj.create_course(
        school_obj, course_name
    )

    return True, f'[{course_name}] 课程创建成功, 绑定给[{school_name}]校区!'


# 管理员创建老师接口
def create_teacher_interface(teacher_name, admin_name, teacher_pwd='123'):

    # 1.判断老师是否存在
    teacher_obj = models.Teacher.select(teacher_name)

    # 2.若存在，则返回不能创建
    if teacher_obj:
        return False, '老师已存在!'

    # 3.若不存在，则创建老师，让 管理员 来创建
    admin_obj = models.Admin.select(admin_name)
    admin_obj.create_teacher(teacher_name, teacher_pwd)

    return True, f'[{teacher_name}]老师创建成功!'

'''公共接口'''
import os
from conf import settings
from db import models


# 获取所有学校名称接口
def get_all_school_interface():
    # 1.获取学校文件夹路径
    school_dir = os.path.join(
        settings.DB_PATH, 'School'
    )

    # 2.判断文件夹是否存在
    if not os.path.exists(school_dir):
        return False, '没有学校，请先联系管理员'

    # 3.文件夹若存在，则获取文件夹中所有文件的名字
    school_list = os.listdir(school_dir)
    return True, school_list


# 公共登录接口
def login_interface(user, pwd, user_type):
    if user_type == 'admin':
        obj = models.Admin.select(user)

    elif user_type == 'student':
        obj = models.Student.select(user)

    elif user_type == 'teacher':
        obj = models.Teacher.select(user)

    else:
        return False, '登录角色不对，请输入角色'

    # 1.判断用户是否存在
    if obj:
        # 2.若用户存在，则校验密码
        if pwd == obj.pwd:
            return True, '登录成功! '
        else:
            return False, '密码错误!'

    else:
        # 3.若不存在，则证明用户不存在并返回给视图层
        return False, '用户名不存在!'


# 获取学校下所有课程接口
def get_course_in_school_interface(school_name):

    # 1、获取学校对象
    school_obj = models.School.select(school_name)

    # 2、获取学校对象下所有课程
    course_list = school_obj.course_list

    if not course_list:
        return False, '该学校没有课程'

    return True, course_list

'''
学生接口层
'''
from db import models


# 学生注册接口
def student_register_interface(user, pwd):
    # 1.判断用户是否存在
    # 调用Student类中的，select方法，
    # 由该方法去调用db_handler中的select_data功能获取对象
    student_obj = models.Student.select(user)

    # 1.1) 若存在不允许注册，返回用户已存在给视图层
    if student_obj:
        return False, '学生用户已存在!'

    # 1.2) 若不存在则允许注册，调用类实例化得到对象并保存
    student_obj = models.Student(user, pwd)
    # 对象调用save() 会将 admin_obj传给save方法
    student_obj.save()

    return True, '注册成功!'


# 学生登录接口
'''
def student_login_interface(user, pwd):
    # 1.判断用户是否存在
    student_obj = models.Student.select(user)

    # 2.若不存在，则证明用户不存在并返回给视图层
    if not student_obj:
        return False, '用户名不存在!'

    # 3.若用户存在，则校验密码
    if pwd == student_obj.pwd:
        return True, '登录成功! '
    else:
        return False, '密码错误!'
'''


# 学生选择学校接口
def add_school_interface(school_name, student_name):
    # 1、判断当前学生是否存在学校
    student_obj = models.Student.select(student_name)

    if student_obj.school:
        return False, '当前学生已经选择过学校了!'

    # 2、若不存在学校，则给调用学生对象中选择学校的方法，实现学生添加学校
    student_obj.add_school(school_name)
    return True, '选择学校成功!'


# 获取学生所在学校所有课程接口
def get_course_list_interface(student_name):
    # 1、获取当前学生对象
    student_obj = models.Student.select(student_name)
    school_name = student_obj.school
    # 2、判断当前学生是有学校，若没有则返回False
    if not school_name:
        return False, '没有学校，请先选择学校'

    # 3、开始获取学校对象中的课程列表
    school_obj = models.School.select(school_name)

    # 3.1、判断当前学校中是否有课程，若没有，则联系管理员
    course_list = school_obj.course_list
    if not course_list:
        return False, '没有课程，请先联系管理员创建'

    # 3.2、若有则，返回课程列表
    return True, course_list


# 学生选择学校接口
def add_course_interface(course_name, student_name):
    # 1、先判断当前课程是否已经存在学生课程列表中
    student_obj = models.Student.select(student_name)

    if course_name in student_obj.course_list:
        return False, '该课程已经选择过了!'

    # 2、调用学生对象中添加课程的方法
    student_obj.add_course(course_name)

    return True, f'[{course_name}] -- 课程添加成功!'


# 学生会查看分数接口
def check_score_interface(student_name):
    student_obj = models.Student.select(student_name)
    if student_obj.score_dict:
        return student_obj.score_dict

'''
老师接口层
'''
from db import models


# 老师查看课程接口
def check_course_interface(teacher_name):
    # 1、获取当前老师对象
    teacher_obj = models.Teacher.select(teacher_name)

    # 2、判断老师对象中课程列表是否有值
    # 让老师对象，调用查看教授课程方法，返回课程
    # course_list = teacher_obj.course_list_from_tea
    course_list = teacher_obj.show_course()

    # 3、若有则返回True， 无则返回False
    if not course_list:
        return False, '老师没有选择课程'

    return True, course_list


# 老师添加课程接口
def add_course_interface(course_name, teacher_name):
    # 1、获取当前老师对象
    teacher_obj = models.Teacher.select(teacher_name)

    # 2、判断当前课程是否在老师的课程列表中
    course_list = teacher_obj.course_list_from_tea
    if course_name in course_list:
        return False, '该课程已存在!'

    # 3、若不存在，则添加该课程到老师课程列表中
    teacher_obj.add_course(course_name)

    return True, '添加课程成功!'


# 老师获取课程下学生接口
def get_student_interface(course_name, teacher_name):
    # 1、获取当前老师对象
    teacher_obj = models.Teacher.select(teacher_name)

    # 2、让当前老师对象，调用获取课程下所有学生功能
    student_list = teacher_obj.get_student(course_name)

    # 3、判断课程下是否有学生
    if not student_list:
        return False, '学生没有选择该课程'

    return True, student_list


# 老师修改分数接口
def change_score_interface(course_name, student_name, score, teacher_name):

    # 1、获取老师对象
    teacher_obj = models.Teacher.select(teacher_name)

    # 2、让老师对象调用修改分数方法
    teacher_obj.change_score(course_name, student_name, score)

    return True, '修改分数成功！'

lib

''''''
'''公共方法'''


# 多用户登录认证装饰器
def auth(role):
    '''
    :param role: 角色 ---》 管理员、学生、老师
    :return:
    '''
    from core import admin, student, teacher
    # 登录认证装饰器
    def login_auth(func):
        def inner(*args, **kwargs):
            if role == 'admin':
                if admin.admin_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    admin.login()

            elif role == 'student':
                if student.student_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    student.login()

            elif role == 'teacher':
                if teacher.teacher_info['user']:
                    res = func(*args, **kwargs)
                    return res
                else:
                    teacher.login()

            else:
                print('当前视图没有权限')

        return inner

    return login_auth

start.py

'''
启动项目入口
'''

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

from core import src

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

README.MD

'''
本周作业

角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 创建讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校
6. 提供两个角色接口
6.1 学员视图， 可以注册，选择班级
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程

7. 上面的操作产生的数据都通过pickle序列化保存到文件里


'''

1.需求分析  (课程与班级合为一体)
    --管理员视图
        -1.注册
        -2登录
        -3创建学校
        -4创建课程(先选择学校)
        -5创建讲师
    --学生视图
        -1注册
        -2登录功能
        -3选择校区
        -4选择课程(先选择校区,在选择小区中的某一门课程)
            -学生选择课程,课程也选择学生
        -5查看分数
    --教师视图
        -1登录
        -2查看教授课程
        -3选择教授课程
        -4查看课程下学生
        -5修改学生分数
        

2.程序的架构设计
    -三层架构
        -用户视图层
            -用于与用户进行交互
            -小的逻辑判断,比如注册功能中两次密码是否一致的校验
            -core
                src.py    主视图
                -admin.py
                    admin_view
                -student.py
                    student_view
                -teacher.py
                    teacher_view
                
        -逻辑接口层
            -核心业务逻辑的处理
            -interface
                -admin_interface.py
                -student_interface.py
                -teacher_interface.py
        -数据处理层
            -做数据的处理,比如:数据的增删查改
            -db
                -db_handler.py
                -models1.py


3.分任务开发


4.测试


5.上线