1 import os
 2 import sys
 3 from core import src
 4 
 5 # 添加环境解释器
 6 sys.path.append(
 7     os.path.dirname(__file__)
 8 )
 9 
10 # 执行项目启动
11 if __name__ == ‘__main__‘:
12     src.run()

 1 from core import admin
 2 from core import student
 3 from core import teacher
 4 
 5 
 6 func_dic = {
 7     ‘1‘: admin.admin_view,
 8     ‘2‘: student.student_view,
 9     ‘3‘: teacher.teacher_view,
10 }
11 
12 
13 def run():
14     while 1:
15         print(‘‘‘
16         ==========选课==========
17                 1、管理员
18                 2、学生
19                 3、老师
20         ========================
21         ‘‘‘)
22         choice = input("请输入要操作的编号： ").strip()
23         if choice.lower() == ‘q‘:
24             break
25         if not choice.isdigit():
26             print(‘输入有误，请输入正确的编号！或者"q"结束当前操作！‘)
27             continue
28         if choice not in func_dic:
29             print(‘操作的编号不存在！请从新输入！或者"q"结束当前操作！‘)
30             continue
31         func_dic.get(choice)()

  1 from interface import admin_interface
  2 from lib import common
  3 from interface import common_interface
  4 
  5 user_info = {‘username‘: None}
  6 
  7 # 注册
  8 def register():
  9     # 注册用户
 10     while 1:
 11         username = input(‘请输入你要注册的用户名： ‘).strip()
 12         password = input(‘请输入注册用户的密码： ‘).strip()
 13         re_password = input(‘请再次输入注册用户的密码： ‘).strip()
 14         # 判断用户两次输入密码是否一致，如果一致则调注册接口，否则打印密码不一致
 15         if password == re_password:
 16             # 调用注册接口
 17             flag, msg = admin_interface.register_interface(username, password)
 18             if flag:
 19                 print(msg)
 20                 break
 21             else:
 22                 print(msg)
 23         else:
 24             print(‘两次密码不一致，请重新输入！‘)
 25             continue
 26 
 27 # 登录
 28 def login():
 29     while 1:
 30         # 输入要注册用户名和密码
 31         username = input(‘请输入要登录的用户名： ‘).strip()
 32         password = input(‘请输入登录的密码： ‘).strip()
 33         # 调用（公共）登录接口
 34         flag, msg = common_interface.login_interface(username, password,user_type=‘admin‘)
 35         if flag:
 36             print(msg)
 37             # 修改全局字典
 38             user_info[‘username‘] = username
 39             break
 40         else:
 41             print(msg)
 42 
 43 # 创建学校
 44 @common.login_auth(‘admin‘)
 45 def create_school():
 46     while 1:
 47         # 输入要创建的学校和地址
 48         school_name = input(‘请输入要创建的学校： ‘).strip()
 49         school_addr = input(‘请输入学校地址： ‘).strip()
 50         # 调用创建学校接口
 51         flag,msg = admin_interface.create_school_interface(school_name,school_addr,user_info[‘username‘])
 52         if flag:
 53             print(msg)
 54             break
 55         else:
 56             print(msg)
 57 
 58 # 创建课程
 59 @common.login_auth(‘admin‘)
 60 def create_course():
 61     while 1:
 62         # 调用获取学校信息接口
 63         flag,school_list_msg = common_interface.get_all_school_interface()
 64         # 如果不存在，则结束，否则继续执行
 65         if not flag:
 66             print(school_list_msg)
 67             break
 68         # 获取编号和对应学校名，根据枚举获取
 69         for index,school_name in enumerate(school_list_msg):
 70             print(‘编号：【%s】  学校名：【%s】‘%(index,school_name))
 71         # 用户输入选择学校
 72         choice = input(‘请输入学校编号： ‘).strip()
 73         # 判断输入是否正常
 74         if not choice.isdigit():
 75             print(‘输入有误，请输入数字‘)
 76             continue
 77         choice = int(choice)
 78         if choice not in range(len(school_list_msg)):
 79             print(‘请输入正确的编号！‘)
 80             continue
 81         # 获取输入学校名称
 82         school_name = school_list_msg[choice]
 83         course_name = input(‘请输入要创建的课程： ‘).strip()
 84         # 调用创建课程接口，将获取的学校、以及要创建的课程、操作用户名传入
 85         flag,msg = admin_interface.create_course_interface(school_name,course_name,user_info.get(‘username‘))
 86         if flag:
 87             print(msg)
 88             break
 89         else:
 90             print(msg)
 91 
 92 # 创建老师
 93 @common.login_auth(‘admin‘)
 94 def create_teacher():
 95     while 1:
 96         teacher_name = input(‘请输入要创建的老师： ‘).strip()
 97         # 调用创建老师接口
 98         flag,msg = admin_interface.create_teacher_interface(teacher_name,user_info[‘username‘])
 99         if flag:
100             print(msg)
101             break
102         else:
103             print(msg)
104 
105 
106 func_dic = {
107     ‘1‘: register,
108     ‘2‘: login,
109     ‘3‘: create_school,
110     ‘4‘: create_course,
111     ‘5‘: create_teacher,
112 }
113 
114 
115 def admin_view():
116     while 1:
117         print(‘‘‘
118         - 1、注册
119         - 2、登录
120         - 3、创新学校
121         - 4、创建课程
122         - 5、创建讲师
123         ‘‘‘)
124         choice = input("请输入要操作的编号： ").strip()
125         if choice.lower() == ‘q‘:
126             break
127         if not choice.isdigit():
128             print(‘输入有误，请输入正确的编号！或者"q"结束当前操作！‘)
129             continue
130         if choice not in func_dic:
131             print(‘操作的编号不存在！请从新输入！或者"q"结束当前操作！‘)
132             continue
133         func_dic.get(choice)()

  1 from interface import student_interface
  2 from interface import common_interface
  3 from lib import common
  4 
  5 user_info = {‘username‘: None,‘course‘:None}
  6 
  7 
  8 
  9 def register():
 10     while 1:
 11         user_name = input(‘请输入要注册学生的姓名：‘).strip()
 12         password = input(‘请输入要注册的密码：‘).strip()
 13         re_password = input(‘请再次输入要注册的密码：‘).strip()
 14         if password == re_password:
 15             flag,msg = student_interface.register_interface(user_name,password)
 16             if flag:
 17                 print(msg)
 18                 break
 19             else:
 20                 print(msg)
 21 
 22 def login():
 23     while 1:
 24         user_name = input(‘请输入要登录的学生名： ‘).strip()
 25         password = input(‘请输入登录学生的密码： ‘).strip()
 26         flag,msg = common_interface.login_interface(user_name,password,user_type=‘student‘)
 27         if flag:
 28             print(msg)
 29             user_info[‘username‘] = user_name
 30             break
 31         else:
 32             print(msg)
 33 
 34 @common.login_auth(‘student‘)
 35 def choice_school():
 36     while 1:
 37         flag, school_list_msg = common_interface.get_all_school_interface()
 38         if not flag:
 39             print(school_list_msg)
 40             break
 41         for index,school_name in enumerate(school_list_msg):
 42             print(‘编号：【%s】  学校名：【%s】‘%(index,school_name))
 43         choice = input(‘请输入学校编号： ‘).strip()
 44         if not choice.isdigit():
 45             print(‘输入有误，请输入数字‘)
 46             continue
 47         choice = int(choice)
 48         if choice not in range(len(school_list_msg)):
 49             print(‘请输入正确的编号！‘)
 50             continue
 51         school_name = school_list_msg[choice]
 52         # print(‘你选择的是 %s 校区‘% school_name)
 53         # print(user_info[‘username‘])
 54         flag,msg = student_interface.choice_school_interface(school_name,user_info[‘username‘])
 55         if flag:
 56             print(msg)
 57             user_info[‘course‘] = school_name
 58             break
 59         else:
 60             print(msg)
 61             break
 62 
 63 @common.login_auth(‘student‘)
 64 def choice_course():
 65     while 1:
 66         ‘‘‘
 67                 # # 选择校区
 68         # flag, school_list_msg = common_interface.get_all_school_interface()
 69         # if not flag:
 70         #     print(school_list_msg)
 71         #     break
 72         # for index,school_name in enumerate(school_list_msg):
 73         #     print(‘编号：【%s】  学校名：【%s】‘%(index,school_name))
 74         # choice = input(‘请输入学校编号： ‘).strip()
 75         # if not choice.isdigit():
 76         #     print(‘输入有误，请输入数字‘)
 77         #     continue
 78         # choice = int(choice)
 79         # if choice not in range(len(school_list_msg)):
 80         #     print(‘请输入正确的编号！‘)
 81         #     continue
 82         # school_name = school_list_msg[choice]
 83         # 选择课程
 84         flag,course_list_msg = common_interface.get_all_course_interface()
 85         if not flag:
 86             print(course_list_msg)
 87             break
 88         for index,course_name in enumerate(course_list_msg):
 89             print(‘编号：【%s】  课程名：【%s】‘%(index,course_name))
 90         choice = input(‘请输入课程编号： ‘).strip()
 91         if not choice.isdigit():
 92             print(‘输入有误，请输入数字‘)
 93             continue
 94         choice = int(choice)
 95         if choice not in range(len(course_list_msg)):
 96             print(‘请输入正确的编号！‘)
 97             continue
 98         course_name = course_list_msg[choice]
 99 
100         flag,msg = student_interface.choice_course_interface(course_name,user_info[‘username‘])
101         if flag:
102             print(msg)
103             break
104         else:
105             print(msg)
106         ‘‘‘
107         # 获取当前学生的所在学校的课程列表
108         flag,course_list_msg = student_interface.get_course_list_interface(user_info.get(‘username‘))
109         if not flag:
110             print(course_list_msg)
111             break
112         # 打印课程列表，并让用户选择课程
113         for index,course_name in enumerate(course_list_msg):
114             print(‘编号：【%s】  课程名：【%s】‘%(index,course_name))
115         choice = input(‘请输入课程编号： ‘).strip()
116         if not choice.isdigit():
117             print(‘输入有误，请输入数字‘)
118             continue
119         choice = int(choice)
120         if choice not in range(len(course_list_msg)):
121             print(‘请输入正确的编号！‘)
122             continue
123         course_name = course_list_msg[choice]
124         # 调用学生选择课程接口
125         flag,msg = student_interface.choice_course_interface(course_name,user_info[‘username‘])
126         if flag:
127             print(msg)
128             break
129         else:
130             print(msg)
131             break
132 
133 @common.login_auth(‘student‘)
134 def check_score():
135     score_dict = student_interface.check_score_interface(user_info.get(‘username‘))
136     if not score_dict:
137         print(‘没有选择课程！‘)
138     print(score_dict)
139 
140 func_dic = {
141     ‘1‘: register,
142     ‘2‘: login,
143     ‘3‘: choice_school,
144     ‘4‘: choice_course,
145     ‘5‘: check_score,
146 }
147 
148 
149 def student_view():
150     while 1:
151         print(‘‘‘
152         - 1、注册
153         - 2、登录
154         - 3、选择校区
155         - 4、选择课程
156         - 5、查看分数
157         ‘‘‘)
158         choice = input("请输入要操作的编号： ").strip()
159         if choice.lower() == ‘q‘:
160             break
161         if not choice.isdigit():
162             print(‘输入有误，请输入正确的编号！或者"q"结束当前操作！‘)
163             continue
164         if choice not in func_dic:
165             print(‘操作的编号不存在！请从新输入！或者"q"结束当前操作！‘)
166             continue
167         func_dic.get(choice)()

  1 from interface import teacher_interface
  2 from interface import common_interface
  3 from  lib import common
  4 
  5 user_info = {‘username‘: None}
  6 
  7 def login():
  8     while 1:
  9         username = input(‘请输入要登录的账户： ‘).strip()
 10         password = input(‘请输入登录密码： ‘).strip()
 11         flag,msg = common_interface.login_interface(username,password,user_type=‘teacher‘)
 12         if flag:
 13             print(msg)
 14             user_info[‘username‘] = username
 15             break
 16         else:
 17             print(msg)
 18 
 19 @common.login_auth(‘teacher‘)
 20 def check_course():
 21     flag,course_list = teacher_interface.check_course_interface(user_info.get(‘username‘))
 22     if flag:
 23         print(course_list)
 24     else:
 25         print(course_list)
 26 
 27 @common.login_auth(‘teacher‘)
 28 def choose_course():
 29     while 1:
 30         # 1、打印所有学校，并选择选择
 31         flag,school_list = common_interface.get_all_school_interface()
 32         if not flag:
 33             print(school_list)
 34             break
 35         for index,school_name in enumerate(school_list):
 36             print(‘编号:%s        学校名：%s‘%(index,school_name))
 37         # 老师输入学校编号
 38         choice = input(‘请输入选择的学校编号： ‘).strip()
 39         if not choice.isdigit():
 40             print(‘输入有误！‘)
 41             continue
 42         choice = int(choice)
 43         if choice not in range(len(school_list)):
 44             print(‘输入的编号有误！‘)
 45             continue
 46         school_name = school_list[choice]
 47         # 2、从选择的学校中获取所有课程
 48         flag2,course_list = common_interface.get_all_course_interface(school_name)
 49         if not flag2:
 50             print(course_list)
 51             break
 52         for index,course_name in enumerate(course_list):
 53             print(‘编号:%s        课程名：%s‘%(index,course_name))
 54         # 老师输入学校编号
 55         choice2 = input(‘请输入选择的学校编号： ‘).strip()
 56         if not choice2.isdigit():
 57             print(‘输入有误！‘)
 58             continue
 59         choice2 = int(choice2)
 60         if choice2 not in range(len(course_list)):
 61             print(‘输入的编号有误！‘)
 62             continue
 63         course_name = course_list[choice2]
 64         # 3、将课程添加到老师课程中
 65         flag3 ,msg = teacher_interface.add_course_interface(course_name,user_info.get(‘username‘))
 66         if flag3:
 67             print(msg)
 68             break
 69         else:
 70             print(msg)
 71 
 72 # 查看课程下学生
 73 @common.login_auth(‘teacher‘)
 74 def check_stu_from_course():
 75     while 1:
 76         # 先获取老师所有的课程
 77         flag, course_list = teacher_interface.check_course_interface(user_info.get(‘username‘))
 78         if not flag:
 79             print(course_list)
 80             break
 81         for index, course_name in enumerate(course_list):
 82             print(‘编号:%s        课程名：%s‘ % (index, course_name))
 83         # 老师输入学校编号
 84         choice = input(‘请输入选择的学校编号： ‘).strip()
 85         if not choice.isdigit():
 86             print(‘输入有误！‘)
 87             continue
 88         choice = int(choice)
 89         if choice not in range(len(course_list)):
 90             print(‘输入的编号有误！‘)
 91             continue
 92         course_name = course_list[choice]
 93         # 获取课程列表下的学生
 94         flag2,student_list = teacher_interface.get_all_stu_interface(course_name , user_info.get(‘username‘))
 95         if flag2:
 96             print(student_list)
 97             break
 98         else:
 99             print(student_list)
100             break
101 
102 #
103 @common.login_auth(‘teacher‘)
104 def change_score_from_student():
105     while 1:
106         # 先获取老师所有的课程
107         flag, course_list = teacher_interface.check_course_interface(user_info.get(‘username‘))
108         if not flag:
109             print(course_list)
110             break
111         for index, course_name in enumerate(course_list):
112             print(‘编号:%s        课程名：%s‘ % (index, course_name))
113         # 老师输入学校编号
114         choice = input(‘请输入选择的学校编号： ‘).strip()
115         if not choice.isdigit():
116             print(‘输入有误！‘)
117             continue
118         choice = int(choice)
119         if choice not in range(len(course_list)):
120             print(‘输入的编号有误！‘)
121             continue
122         course_name = course_list[choice]
123         # 获取课程列表下的学生
124         flag2,student_list = teacher_interface.get_all_stu_interface(course_name , user_info.get(‘username‘))
125         if not flag2:
126             print(student_list)
127             break
128         for index2,student_name in enumerate(student_list):
129             print(‘编号:%s        学生名：%s‘ % (index2, student_name))
130         choice2 = input(‘请输入选择的学生编号： ‘).strip()
131         if not choice2.isdigit():
132             print(‘输入有误！‘)
133             continue
134         choice2 = int(choice2)
135         if choice2 not in range(len(student_list)):
136             print(‘输入的编号有误！‘)
137             continue
138         student_name = student_list[choice2]
139         score = input(‘请输入要修改的成绩： ‘).strip()
140         if not score.isdigit():
141             continue
142         score = int(score)
143         flag3,msg = teacher_interface.change_score_interface(course_name,student_name,score,user_info.get(‘username‘))
144         if flag3:
145             print(msg)
146             break
147 
148 
149 func_dic = {
150     ‘1‘: login,
151     ‘2‘: check_course,
152     ‘3‘: choose_course,
153     ‘4‘: check_stu_from_course,
154     ‘5‘: change_score_from_student,
155 }
156 
157 
158 def teacher_view():
159     while 1:
160         print(‘‘‘
161         - 1、登录
162         - 2、查看教授课程
163         - 3、选择教授课程
164         - 4、查看课程下学生
165         - 5、修改学生分数
166         ‘‘‘)
167         choice = input("请输入要操作的编号： ").strip()
168         if choice.lower() == ‘q‘:
169             break
170         if not choice.isdigit():
171             print(‘输入有误，请输入正确的编号！或者"q"结束当前操作！‘)
172             continue
173         if choice not in func_dic:
174             print(‘操作的编号不存在！请从新输入！或者"q"结束当前操作！‘)
175             continue
176         func_dic.get(choice)()

1 import os
2 
3 BASE_PATH = os.path.dirname(
4     os.path.dirname(__file__)
5 )
6 
7 DB_PATH = os.path.join(
8     BASE_PATH,‘db‘
9 )

 1 from db import modles
 2 from lib import common
 3 
 4 # 注册接口
 5 def register_interface(username,password):
 6     # 判断用户名是否存在
 7     admin_obj = modles.Admin.select(username)
 8     if admin_obj:
 9         return False,‘用户已存在！‘
10     # 密码加密+加盐
11     password = common.get_password_md5(password)
12     print(password)
13     # 用户不存在则创建用户
14     admin_obj = modles.Admin(username,password)
15     admin_obj.save()
16     return True,‘注册成功！‘
17 
18 # 创建学校接口
19 def create_school_interface(school_name,school_addr,admin_user):
20     # 获取学校，并查看学校是否存在
21     school_obj = modles.School.select(school_name)
22     if school_obj:
23         return False,‘学校存在！‘
24     # 获取用户是否登录
25     admin_obj = modles.Admin.select(admin_user)
26     # 调用创建学校类方法
27     admin_obj.create_school(school_name,school_addr)
28     return True,‘【%s】 学校创建成功！‘%school_name
29 
30 # 创建课程接口
31 def create_course_interface(school_name,course_name,admin_user):
32     # 判断学校是否存在
33     school_obj = modles.School.select(school_name)
34     # 判断课程是否在学校列表中
35     if course_name in school_obj.course_list:
36         return False, ‘课程存在！‘
37     # 获取当前用户是否存在
38     admin_obj = modles.Admin.select(admin_user)
39     admin_obj.create_course(school_obj,course_name)
40     return True,‘【%s】课程创建成功！‘%course_name
41 
42 # 创建老师接口
43 def create_teacher_interface(teacher_name,admin_user,pwd = ‘123‘):
44     # 查看教师是否存在
45     teacher_obj = modles.Teacher.select(teacher_name)
46     if teacher_obj:
47         return False,‘教师已存在！‘
48     pwd = common.get_password_md5(pwd)
49     admin_obj = modles.Admin.select(admin_user)
50     admin_obj.create_teacher(teacher_name,pwd)
51     return True,‘【%s】老师创建成功！‘%teacher_name

 1 from db import modles
 2 from lib import common
 3 
 4 
 5 def register_interface(user_name,password):
 6     stu_obj = modles.Student.select(user_name)
 7     if stu_obj:
 8         return False,‘注册用户已存在！‘
 9     password = common.get_password_md5(password)
10     stu_obj = modles.Student(user_name,password)
11     stu_obj.save()
12     return True,‘注册成功！‘
13 
14 
15 # 选择校区
16 def choice_school_interface(school_name,user_name):
17     # 判断该学生是否已在这个校区
18     student_obj = modles.Student.select(user_name)
19 
20     if student_obj.school_name:
21         return False,‘该学生已经选择校区！‘
22     # 如果不存在，则保存
23     # 查看学生实例
24     student_obj.choice_school(school_name)
25     return True, ‘选择 %s 校区完成！‘ % school_name
26 
27 # 获取学生所在学校所有课程
28 def get_course_list_interface(user_name):
29     stu_obj = modles.Student.select(user_name)
30     if not stu_obj.school_name:
31         return False,‘当前学生还没有选择学校！‘
32     # 开始获取学校对象
33     school_obj = modles.School.select(stu_obj.school_name)
34     # 判断当前学校是否有课程
35     if not school_obj.course_list:
36         return False,‘没有课程，先联系管理员！‘
37     return True, school_obj.course_list
38 
39 # 选择课程接口
40 def choice_course_interface(course_name,user_name):
41     # 判断该学生是否存在已选择课程
42     stu_obj = modles.Student.select(user_name)
43     # 判断课程是否已经存在
44     if course_name in stu_obj.course_list:
45         return False,‘该学生已经选择了这个课程‘
46     # 调用学生对象中添加课程的方法
47     stu_obj.add_course(course_name)
48     return True, ‘选择 %s 课程完成！‘ % course_name
49 
50 # 查看分数接口
51 def check_score_interface(user_name):
52     student_obj = modles.Student.select(user_name)
53     if student_obj.score_dict:
54         return student_obj.score_dict

 1 from db import modles
 2 from lib import common
 3 
 4 # def teacher_login_interface(username,password):
 5 #     teacher_obj = modles.Teacher.select(username)
 6 #     # print(teacher_obj.__dict__)
 7 #     if not teacher_obj:
 8 #         return False, ‘用户不存在！‘
 9 #     password = common.get_password_md5(password)
10 #     if password == teacher_obj.pwd:
11 #         return True, ‘登录成功！‘
12 #     else:
13 #         return False, ‘密码错误！‘
14 
15 def check_course_interface(username):
16     # 获取老师的对象
17     teacher_obj = modles.Teacher.select(username)
18     # 将老师可的课程列表读取
19     # course_list = teacher_obj.course_list_tea
20     course_list = teacher_obj.show_course()
21     # 判断老师课程是否存在
22     if not course_list:
23         return False,‘当前老师还是没有选择课程！‘
24     return True,course_list
25 
26 def add_course_interface(course_name,username):
27     # 获取老师对象
28     teacher_obj = modles.Teacher.select(username)
29     # 判断当前课程是否在老师列表
30     course_list = teacher_obj.course_list_tea
31     if course_name in course_list:
32         return  False,‘该课程已存在！‘
33     # 若不存在，则添加该课程到老师的课程列表中
34     teacher_obj.add_course(course_name)
35     return True,‘添加课程成功！‘
36 
37 def get_all_stu_interface(course_name , username):
38     # 获取当前老师对象
39     teacher_obj = modles.Teacher.select(username)
40     # 让老师对象调用获取课程下所有学生功能
41     student_list = teacher_obj.get_student(course_name)
42     if not student_list:
43         return False,‘学生没有选择该课程！‘
44     return True,student_list
45 
46 def change_score_interface(course_name,student_name,score,username):
47     teacher_obj = modles.Teacher.select(username)
48     teacher_obj.change_score(course_name,student_name,score)
49     return True,‘修改成功‘

 1 import os
 2 from conf import settings
 3 from core import student
 4 from db import modles
 5 from lib import common
 6 
 7 # 获取学校信息
 8 def get_all_school_interface():
 9     # 获取学校文件夹的路径
10     school_dir = os.path.join(
11         settings.DB_PATH,‘School‘
12     )
13     # 判断文件是否存在
14     if not os.path.exists(school_dir):
15         return False,‘没有学校，请先联系管理员！‘
16     # 若文件夹存在，则获取文件夹中所有的文件的名字
17     school_list = os.listdir(school_dir)
18     return True,school_list
19 
20 # 获取课程信息
21 def get_all_course_interface(school_name):
22     school_obj = modles.School.select(school_name)
23     course_list = school_obj.course_list
24     if not course_list:
25         return False,‘当前没有课程！‘
26     return True,course_list
27 
28 
29 # 公共登录接口
30 def login_interface(username,password,user_type):
31     # 判断传入用户名
32     if user_type == ‘admin‘:
33         # 判断用户是否存在
34         obj = modles.Admin.select(username)
35     elif user_type == ‘student‘:
36         # 判断用户是否存在
37         obj = modles.Student.select(username)
38     elif user_type == ‘teacher‘:
39         # 判断用户是否存在
40         obj = modles.Teacher.select(username)
41     else:
42         return False,‘登录角色不对，请重新输入!‘
43     if not obj:
44         return False,‘用户不存在！‘
45     # 密码加密
46     password = common.get_password_md5(password)
47     # print(password)
48     # print(‘====‘,admin_obj.pwd)
49     # 判断密码是否相同
50     if password == obj.pwd:
51         return True, ‘登录成功！‘
52     else:
53         return False, ‘密码错误！请重新输入！‘

 1 import os
 2 import pickle
 3 from conf import settings
 4 
 5 def select_data(cls,username):
 6     # 获取类名字
 7     class_name = cls.__name__
 8     # 拼接文件名
 9     user_dir_path = os.path.join(
10         settings.DB_PATH,class_name
11     )
12     # 判断文件夹是否存在
13     if not os.path.exists(user_dir_path):
14         os.mkdir(user_dir_path)
15     # 判断用户是否存在(拼接用户路径)
16     user_path = os.path.join(
17         user_dir_path,username
18     )
19     if os.path.exists(user_path):
20         with open(user_path,‘rb‘) as f:
21             obj = pickle.load(f)
22             return obj
23 
24 
25 
26 def save_data(obj):
27     # 获取类名
28     class_name = obj.__class__.__name__
29     # 拼接文件路径
30     user_dir_path = os.path.join(
31         settings.DB_PATH,class_name
32     )
33     # 判断文件夹是否存在
34     if not os.path.exists(user_dir_path):
35         os.mkdir(user_dir_path)
36     # 拼接用户文件路径
37     user_path = os.path.join(
38         user_dir_path,obj.user
39     )
40     with open(user_path,‘wb‘) as f:
41         pickle.dump(obj,f)

 1 from db import db_handler
 2 
 3 
 4 class Bsse:
 5     @classmethod
 6     def select(cls ,username):
 7         obj = db_handler.select_data(cls, username)
 8         return obj
 9 
10     def save(self):
11         db_handler.save_data(self)
12 
13 class Admin(Bsse):
14     def __init__(self,username,password):
15         self.user = username
16         self.pwd = password
17 
18     def create_school(self,school_name,school_addr):
19         school_obj = School(school_name,school_addr)
20         school_obj.save()
21 
22     def create_course(self,school_obj,course_name):
23         # 调用课程类，实例化创建课程
24         course_obj = Course(course_name)
25         course_obj.save()
26         # 获取当前学校对象，并将课程添加到课程列表
27         school_obj.course_list.append(course_name)
28         school_obj.save()
29 
30     def create_teacher(self,teacher_name,pwd):
31         teacher_obj = Teacher(teacher_name,pwd)
32         teacher_obj.save()
33 
34 
35 class Student(Bsse):
36     def __init__(self,username,password):
37         self.user = username
38         self.pwd = password
39         self.school_name = None
40         self.course_list = []
41         self.score_dict = {}
42 
43     def choice_school(self,school_name):
44         self.school_name = school_name
45         self.save()
46     # 学生添加课程方法
47     def add_course(self,course_name):
48         self.course_list.append(course_name)
49         self.score_dict[course_name] = 0
50         self.save()
51         # 学生选择的课程对象添加学生
52         cou_obj = Course.select(course_name)
53         cou_obj.stu_list.append(self.user)
54         cou_obj.save()
55 
56 
57 class School(Bsse):
58     def __init__(self,name,addr):
59         self.user = name
60         self.addr = addr
61         self.course_list = []
62 
63 
64 class Teacher(Bsse):
65     def __init__(self,username,pwd):
66         self.user = username
67         self.pwd = pwd
68         self.course_list_tea = []
69 
70     def show_course(self):
71         return self.course_list_tea
72 
73     def add_course(self,course_name):
74         self.course_list_tea.append(course_name)
75         self.save()
76 
77     def get_student(self,course_name):
78         course_obj = Course.select(course_name)
79         return course_obj.stu_list
80 
81     def change_score(self,course_name,student_name,score):
82         student_obj = Student.select(student_name)
83         student_obj.score_dict[course_name] = score
84         student_obj.save()
85 
86 class Course(Bsse):
87     def __init__(self,name):
88         self.user = name
89         self.stu_list = []

 1 import hashlib
 2 
 3 # 密码加密加盐
 4 def get_password_md5(pwd):
 5     md5_obj = hashlib.md5()
 6     md5_obj.update(pwd.encode(‘utf-8‘))
 7     salt = ‘King‘
 8     md5_obj.update(salt.encode(‘utf-8‘))
 9     return md5_obj.hexdigest()
10 
11 # 认证登录装饰器
12 ‘‘‘
13 装饰器框架：
14 def fun_auth(func):
15     def wrapper(*args,**kwargs):
16         res = func(*args,**kwargs)
17         return res
18     return wrapper
19 ‘‘‘
20 
21 def login_auth(role):
22     from core import admin,student,teacher
23     def fun_auth(func):
24         def wrapper(*args,**kwargs):
25             if role == ‘admin‘:
26                 if admin.user_info[‘username‘]:
27                     res = func(*args,**kwargs)
28                     return res
29                 else:
30                     admin.login()
31             elif role == ‘student‘:
32                 if student.user_info[‘username‘]:
33                     res = func(*args, **kwargs)
34                     return res
35                 else:
36                     student.login()
37             elif role == ‘teacher‘:
38                 if teacher.user_info[‘username‘]:
39                     res = func(*args, **kwargs)
40                     return res
41                 else:
42                     teacher.login()
43             else:
44                 print(‘当前视图不存在！‘)
45         return wrapper
46     return fun_auth
47 
48 
49 # 校区装饰器装饰器
50 #
51 # from core import student
52 # def fun_auth(func):
53 #     def wrapper(*args,**kwargs):
54 #             if student.user_info[‘username‘]:
55 #                 res = func(*args,**kwargs)
56 #                 return res
57 #             else:
58 #                 student.choice_school()
59 #     return wrapper