# 选课系统 角色: 学校、学员、课程、讲师、管理员 要求: 1. 创建北京、上海 2 所学校 ---> 管理员创建学校 2. 创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开 3. 课程包含，周期，价格，通过学校创建课程 4. 创建讲师 5. 创建学员时，选择学校，关联班级 5. 创建讲师 6. 提供两个角色接口 6.1 学员视图， 可以注册，选择课程（等同于选择班级） 6.2 讲师视图， 讲师可管理自己的课程， 上课时选择班级，查看班级学员列表 ， 修改所管理的学员的成绩 6.3 管理视图，创建讲师， 创建班级，创建课程 7. 上面的操作产生的数据都通过pickle序列化保存到文件里 - 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 - common_interface.py(公共接口) - 数据处理层 - 做数据的处理，比如数据的 增、删、查、改 - db - models.py - 用于存放所有类，管理所有的类 - Base: # 保存数据 - save(self): db_handler.save_data() @classmethod - select(cls, username): obj = db_handler.select_data(cls, username) return obj - Admin(Base) - __init__(self, admin_name, pwd): self.user = admin_name self.pwd = pwd # 管理员的创建学校方法 - create_school(): school_obj = School() school_obj.save() # 管理员的创建课程方法 - create_course(school_obj, course_name): course_obj = Course() course_obj.save() school_obj.course_list.append(course_name) # 管理员的创建老师方法 - create_teacher(self, teacher_name, teacher_pwd): tea_obj = Teacher(teacher_name, teacher_pwd) tea_obj.save() - School(Base): __init__(self, school_name, school_addr) self.user = school_name self.addr = school_addr self.course_list = [] - Student(Base): __init__(self, user, pwd): self.user = user self.pwd = pwd self.school = None self.course_list = [] self.score_dict = {} - Course(Base): __init__(self, course_name): self.user = course_name self.student_list = [] - Teacher(Base): __init__(self, teacher_name, teacher_pwd): self.user = teacher_name self.pwd = teacher_pwd self.course_list_from_teacher = [] - db_handler.py - save_data(obj) 保存 对象 - 拼接文件夹，以类名当做文件夹管理文件 class_name = obj.__class__.__name__ - 再拼接文件，然后把对象通过pickle序列化到pickle文件中 - select_data(cls, username): - 拼接文件夹，以类名当做文件夹管理文件 class_name = cls.__name__ - 再拼接文件，然后把通过pickle反序列化得到pickle文件中的对象 - 选课系统(******) - pickle 保存对象 - object ---> pickle
选课系统总结： - 管理员 - 注册 1.用户在视图层输入用户名与密码，交给接口层 2.接口层调用数据层中的models.select进行校验。 3.若不存在则创建，并将注册成功返回给视图层。 4.存在则返回存在信息无法注册 - 登录 1.用户在视图层输入用户名与密码，交给接口层 2.接口层调用数据层中的models.select进行校验。 3.若用户名存在则校验密码，并将登录成功返回给视图层。 4.用户名不存在则返回给用户 - 创建学校 1.让用户输入学校名与学校地址 2.调用管理员创建学校接口 3.判断学校是否存在，若存在不让创建 4.若不存在，则调用接口层创建学校，获取管理员对象的创建学校方法保存学校 5.将结果返回给视图层。 - 创建课程 1.获取所有学校，并打印，让用户选择 2.获取用户选择的学校与创建的课程，交给接口层 3.接口层调用管理员对象中的创建课程方法，保存课程对象。 4.课程需要绑定给学校对象，最终将创建成功的结果返回给视图层。 - 创建老师 1.让用户输入老师的名称 2.调用接口层，接口层中设置默认密码123，调用数据层。 3.判断老师是否存在，不存在则调用管理员对象中的创建老师方法。 4.保存老师对象，并将结果返回视图层。 - 学生 - 注册 - 同上 - 登录 - 同上 - 选择学校 1.获取所有学校，让学生选择，将选择的学校传给接口层 2.接口层判断当前学生是否选择学校 3.若没有选择，则调用学生对象中的添加学校方法。 4.将添加后消息返回给视图层。 - 选择课程 1.先获取当前学生所在学校的所有课程，并选择 2.接口层将选择后课程，调用数据层的添加课程方法保存。 3.学生对象中课程列表添加该课程，设置课程分数默认为0。 4.最终将结果返回给视图层 - 查看成绩 1.直接调用接口层 2.接口层调用数据层中的查看成绩方法 3.返回成绩给视图层并打印。 - 老师 - 登录 - 同上 - 查看教授课程 1.直接调用接口层，获取老师对象下课程列表数据 2.若有则打印，没有则退出 - 选择教授课程 1.调用接口层中的选择教授课程接口，调用数据层中该课程下所有的学生返回给视图层 2.打印所有的课程，让老师选择，若老师课程中有该课程则不让添加。 3.没有，则调用老师对象中的添加课程方法进行添加。 - 查看课程下学生 1.直接获取老师对象下所有的课程，选择课程 2.从老师对象中，调用查看课程下学生方法，获取课程对象下所有的学生，返回给视图层 3.视图层打印该课程下所有的学生。 - 修改学生分数 1.直接获取老师对象下所有的课程，选择课程 2.从老师对象中，调用查看课程下学生方法，获取课程对象下所有的学生，返回给视图层 3.视图层打印该课程下所有的学生，并让用户选择需要修改分数的学生。 4.调用老师修改分数接口，获取老师对象，调用对象中的修改分数方法 5.获取学生对象中的score_dict分数字典，进行修改。
目录结构：
import os import sys sys.path.append(os.path.dirname(__file__)) from core import src if __name__ == '__main__': src.run()
import os BASE_PATH = os.path.dirname(os.path.dirname(__file__)) DB_PATH = os.path.join(BASE_PATH, 'db')
from core import admin from core import student from core import teacher func_dict = { '1': admin.admin_view, '2': student.student_view, '3': teacher.teacher_view, } def run(): while True: print(''' ====== 欢迎来到选课系统 ====== 1.管理员功能 2.学生功能 3.老师功能 =========== end ============= ''') choice = input('请输入功能编号: ').strip() if choice not in func_dict: print('输入有误，请重新输入!') continue func_dict.get(choice)()
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 = common_interface.login_interface( username, password, user_type='admin' ) 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 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)()
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()
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 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}]老师创建成功!'
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 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, '修改分数成功！'
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
# 登录装饰器 def auth(role): 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: print('您还没有登录，请先登录！') admin.login() elif role == 'student': if student.student_info['user']: res = func(*args, **kwargs) return res else: print('您还没有登录，请先登录！') student.login() elif role == 'teacher': if teacher.teacher_info['user']: res = func(*args, **kwargs) return res else: print('您还没有登录，请先登录！') teacher.login() else: print('您没有权限！！') return inner return login_auth
