|
|
|
|
|
|
 
import os
BASE_PATH = os.path.dirname(
os.path.dirname(__file__)
)
DB_PATH = os.path.join(
BASE_PATH, 'db'
)
settings
'''管理员视图'''
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)()
admin
''''''
'''
用户视图层的 主视图
'''
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)()
src
'''学生视图'''
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)()
student
'''老师视图'''
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)()
teacher
''''''
'''
用于保存对象与获取对象
'''
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
db__handler
'''用于存放类的
学校类、学员类、课程类、讲师类、管理员类
'''
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()
models
''''''
'''管理员接口'''
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}]老师创建成功!'
admin__interface
''''''
'''公共接口'''
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
common__interface
'''
学生接口层
'''
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
student_interface
'''
老师接口层
'''
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, '修改分数成功！'
teacher__interface
''''''
'''公共方法'''
# 多用户登录认证装饰器
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
common
'''
启动文件入口
'''
import os, sys
sys.path.append(
os.path.dirname(__file__)
)
from core import src
if __name__ == '__main__':
src.run()
start
角色: 学校、学员、课程、讲师、管理员
要求:
1. 创建北京、上海 2 所学校 ---> 管理员创建学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， 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
- 数据处理层
- 做数据的处理，比如数据的 增、删、查、改
- 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 = []
- 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文件中的对象
- ATM + 购物车
- 存放 json格式的数据
- dict --> json
- 选课系统(******)
- pickle 保存对象
- object ---> pickle
3、分任务开发
4、测试
5、线上
选课系统总结：
- 管理员
- 注册
1.用户在视图层输入用户名与密码，交给接口层
2.接口层调用数据层中的models.select进行校验。
3.若不存在则创建，并将注册成功返回给视图层。
- 登录
1.用户在视图层输入用户名与密码，交给接口层
2.接口层调用数据层中的models.select进行校验。
3.若存在则校验密码，并将登录成功返回给视图层。
- 创建学校
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 分数字典，进行修改。
|
|
ヾ(≧O≦)〃嗷~