select 项目<选课系统>

"""1. 创建北京、上海 2 所学校   学校类对象   属性:名字,地址   行为:

2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开3. 课程包含，周期，价格，通过学校创建课程     课程类对象        属性:名字,价格,周期        行为:4. 通过学校创建班级， 班级关联课程、讲师（初始没有设置为空）   班级对象   属性:名字, 课程名称

   讲师对象   属性:名字,密码,校区名称,课程名称

5. 创建学员时，选择学校，关联班级   学生对象:   属性:名字,密码 ,学校名称,班级名称,成绩6. 创建讲师角色时要关联学校 

7. 提供三个角色接口   6.1 学员视图， 可以注册，登陆, 交学费， 选择班级,查看成绩

   6.2 讲师视图,登陆,(注册没有 由管理员来分配账号)， 查看班级学员列表 ， 修改所管理的学员的成绩 ,修改密码

   6.3 管理视图，登陆,创建学校,创建讲师， 创建班级，创建课程,给老师指定班级

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

实现的顺序管理员  老师  学员

"""1.模块的界面

2.管理员代码层

# 管理员代码输入层

# 管理员视图层
from lib import common
from interface import admin_inerface
current_info = None

def register():

    name = input('输入管理员姓名：').strip()
    password = input('输入密码：').strip()
    if name and password:
        flag, msg = admin_inerface.register_interface(name, password)
        if flag:
            print(msg)
        else:
            print(msg)

def login():
    global current_info
    name = input('输入管理员姓名：').strip()
    password = input('输入密码：').strip()
    if name and password:
        flag, msg = admin_inerface.login_interface(name, password)
        if flag:
            print(msg)
            current_info = name
        else:
            print(msg)

def create_school():
    """
    1.输入创建学校所需要的属性 名字和地址
    2.调用接口层判断 接口层拿到数据 到数据处理层处理
    3.返回的到接口层 有则返回F 没有则创建
    4,返回到界面 打印输出

    :return:
    """
    school_name= input('输入学校的名字').strip()

    school_addr = input('输入学校的地址：').strip()
    if school_name and school_addr :
        flag, msg = admin_inerface.create_school_interface(current_info, school_name, school_addr)
        if flag:
            print(msg)
        else:
            print(msg)

def create_teacher():
    """
    1.先选择学校（老师是在学校下面的） 可以封装获取所有学校学校
    2.输入老师的名字和默认密码
     创建老师管理员调用接口层实列化
    :return:
    """
    sc_names_list = admin_inerface.get_schools_interface()
    # print(sc_names_list,'3333')  # ['bj_old', 'sh_old'] 3333

    # 把字在通过索引的形式展现给界面层 >>>封装抽取一个独立函数
    sc_name = common.get_name(sc_names_list, '校区名')
    # 拿到学校的名字 判断 是否存在 在下一步 输入老师的信息
    if not sc_name:
        return
    #  有该学习
    te_name = input('输入老师的名字：').strip()
    pwd = input('输入默认密码：').strip()

    if te_name and pwd:
        # 调用接口层
        flag, msg = admin_inerface.create_teacher_interface(te_name, sc_name,pwd)
        if flag:
            print(msg)
        else:
            print(msg)

def create_classes():  # 先创建课程 课程下添加班级
    """
    1.选择校区
    2.选择课程
    3.输入班级名称
    4.调用接口
    5.展示结果
    :return:
    """
    sc_names = admin_inerface.get_schools_interface()
    # 拿到学校名字
    sc_name = common.get_name(sc_names,'校区名字')
    if not sc_names:
        return False, '学校未创建'

    # 获取课程列表
    c_course_list = admin_inerface.get_course_interface(sc_name)
    # print(c_course_list,'c_course_list')
    c_name = common.get_name(c_course_list,'课程名字')
    if not c_name:
        return False, '课程还没有创建'

    # 有的话 在选择班级
    cl_name = input('输入要创建的班级：').strip()
    flag, msg = admin_inerface.create_classes_interface(sc_name,c_name,cl_name)
    if flag:
        print(msg)
    else:
        print(msg)

def create_course():
    """
     选择校区就可以
     你的现获取所有学校
     选好学校 在改学校下创建课程
    :return:
    """
    sc_names = admin_inerface.get_schools_interface()  # 设计列表 面向对象思想 存的都是对象
    sc_name = common.get_name(sc_names, '校区名字')  # 封装

    # 判断返回的校区名是否存在
    if not sc_name:
        return
    # 有则添加课程信息
    course_name = input('输入课程名字：').strip()
    price = input('输入课程价格:').strip()
    cycle = input('输入课程周期：').strip()

    # 调用接口层 传值要设计好是位置参数
    flag, msg = admin_inerface.create_course_interface(sc_name, course_name, price, cycle)
    if flag:
        print(msg)
    else:
        print(msg)

# 给老师添加课程  是给老师的所在班级添加课程呢  最后式老师班级
def add_course_to_teacher():
    """
    明确输入层要干嘛 给老师加课程
    1、选择学校
    2、选择一个老师
    3、选择一个课程
    4、选择一个班级
    5、将校区名字 老师名字 课程名字 班级名字 传给接口称

    :return:
    """

    # 获取学校名字
    sc_names = admin_inerface.get_schools_interface()
    sc_name = common.get_name(sc_names,'学校名字')
    if not sc_name:
        return

    #  获取一会老师的 老师选择课程  课程之后才有班级
    te_names = admin_inerface.get_teacher_interface(sc_name)  # 取所有老师的名字 不需要传参
    te_name = common.get_name(te_names, '老师的名字')  # te_name = list[choice] 取值
    if not te_name:
        return

    #
     # 获取课程名字 班级也创建好了
    c_names = admin_inerface.get_course_interface(sc_name)
    c_name = common.get_name(c_names,'课程名字')
    if not c_name:
        return

    # 获取班级名字

    # 1.去接口层
    cl_names = admin_inerface.get_classes_interface(sc_name)  # 取所有

    # 调用公共方法报道名字
    cl_name = common.get_name(cl_names, '班级名字')

    # 判断
    if not cl_name:
        return

    # 调用接口层 发送数数据  >>>> 接收结果

    flag, msg = admin_inerface.add_course_to_teacher_interface(sc_name,c_name,te_name,cl_name)
    if flag:
        print(msg)
    else:
        print(msg)

func_dic = {
    ":register,
    ":login,
    ":create_school,
    ":create_teacher,
    ":create_classes,
    ":create_course,
    ":add_course_to_teacher,
}

def admin_views():
    msg = (""" -----欢迎 登录管理员功能层-----
    0.注册
    1、登录
    2、创建学校
    3、创建老师
    4、创建班级
    5、创建课程
    6、选择老师课程及班级
    q、退出

    """)
    common.select_func(func_dic, msg)

管理员接口层代码

# 管理员注册接口层层
# from db.models import *
from db import models,db_handels

def register_interface(name, password):
    """

    :param name: 管理员名字
    :param password: 管理员密码
    :return: 返回是bool  和字符串提示信息

    思路：
        1. 直接用类名 通过models select()方法  返回是一个对象 再判断 在返回False
        2.先判断名字是否存在

        3.不在直接创建利用Admin 直接创建

    """
    admin_obj = models.Admin.select(name)
    print(admin_obj)
    if admin_obj:
        return False, "用户已存在"
    res = models.Admin(name, password)
    res.save()
    return True, '注册成功'

# 用户登录接口
def login_interface(name,pwd):
    """

    :param name:
    :param pwd:
    :return: bool + str
    1.用类调取名对象
    2.判断对象是否存在
    3.不在则返回return
    4.在判断密码
    输入的和存的一样则返回正确

    """
    admin_obj = models.Admin.select(name)
    print(admin_obj,'admin_obj')
    if not admin_obj:
        return False, '用户不存在'
    if pwd == admin_obj.pwd:
        return True, '登录成功'

# 创建学校
def create_school_interface(current_info, school_name, school_addr):
    """

    :param current_info: 当前登录的名字：
    :param school_name: 学校可名
    :param school_addr: 学校地址
    :return: T /F
    思路：
        1。调用接口层
    """
    school_obj = models.School.select(school_name)
    if school_obj:
        return False, '学校已存在'
    # 实列化学校
    models.School(school_name, school_addr)

    return True, '学校创建成功'

# 创建学校
def create_teacher_interface(te_name,sc_name, pwd ):
    """

    :param te_name: 老师的名字
    :param pwd: 老师的密码
    :return: 返回值
    1、调用接口层将数据传输到数据处理层
    2、存在则直接返回 不存在者直接实列化
    3、将处理的结果都返回给用层界面
    """
    te_obj = models.Teacher.select(sc_name+te_name)
    ')
    if te_obj:
        return False, "老师已存在"
    models.Teacher(sc_name+te_name, sc_name, pwd)

    return True, "创建老师成功"

# 获取所有学校
def get_schools_interface():

    """
     # 获取的所有学校称
        1.通过学校这个类获取所有学校对象
        2.拿到一个返回值 是一个列表对象
        3.for循环拿出每一个对象
        4.通过点语法获取名字
        5.产生一个新列表 （学校名字）

    :return:
    """
    sc_list_obj = models.School.get_all()  # 可以将这个当一个类方法使用 可吧帮我们获取对象文件的列表

    res = []
    for i in sc_list_obj:
        res.append(i.name)
    return res

# 接口层创建学校
def create_course_interface(sc_name, course_name, price, cycle):
    course_name_obj = models.Course.select(sc_name+course_name)  # 存储式拼接的格式

    if course_name_obj:
        return False, '课程已存在'
    models.Course(sc_name+course_name, price, cycle,sc_name)  # 位置参数必须一一对应
    return True, '课程创建成功'

# 获取课程列表
def get_course_interface(sc_name):
    c_course_list = models.Course.get_all()
    print('c_course_list',c_course_list)

    # 拿到课程名字
    res = []
    for a in c_course_list:
        if a.sc_name == sc_name:

            res.append(a.name[len(sc_name):])
    return res

# 管理员创建班级
def create_classes_interface(sc_name,c_name,cl_name):
    """

    :param sc_name: 学校名
    :param c_name: 课程名
    :param cl_name: 班级名
    :return: 返回结果
    1.调接口层 班级 moles
    2.判断是否存在
    3、创建
    4、返回界面

    """
    cl_obj = models.Classes.select(sc_name+cl_name)
    if cl_obj:
        return False, '班级已经创建'

    # =无则创建
    models.Classes(sc_name+cl_name, c_name, sc_name)
    return True, '班级创建成功'

# 获取老师的所有名字
def get_teacher_interface(sc_name):
    """
    老师已经创建好了
    te_names = models.Teacher.get_all()
    # 拿到 返回的一个老帅 对象列表
    # 循环取值 获取老师 >>> 获取老师名字
    :return:返回一个对象列表

    """
    res = []  # 123kk names
    te_names = models.Teacher.get_all()

    for a in te_names:
        if a.sc_name == sc_name:
            res.append(a.name[len(sc_name):])
    return res

# 接口层获取班级列表 get_all 方法
def get_classes_interface(sc_name):  #

    cl_names = models.Classes.get_all()

    # 在接口层给他遍历
    res = []
    for a in cl_names:
        if a.sc_name == sc_name:
            res.append(a.name[len(sc_name):])
    return res

# 加课程接口层逻辑处理  >>>> 将接收的数据调用数据处理层 >>>返回结果
def add_course_to_teacher_interface(sc_name, c_name, te_name, cl_name):
    # 用models 获取数据
    # c_obj = models.Classes.select(sc_name+c_name)
    # if not c_obj:
    #     return False, '课程已存在'
    #
    # # 创建
    # models.Classes(sc_name+c_name, te_name, cl_name)  # models
    # return True, '创建成功'

    """

    :param sc_name: 学校名称
    :param c_name: 课程名称
    :param te_name: 老师名称
    :param cl_name: 班级名称
    :return:
    1.找到老师设置他的课程
    2.找到对应的班级 设置老师

    """
    te_obj = models.Teacher.select(sc_name+te_name)
    # 将当前课程绑定给当前老师
    te_obj.c_name = c_name
    te_obj.save()  # 保存课程

    # 将老师关联班级
    cls_obj = models.Classes.select(sc_name+cl_name)

    # 判断班级是否已经选择 老师绑班级
    if cls_obj.te_name == te_name:
        return False, '班级已经绑定过老师了'
    # 如果没有则将老师绑定给班级
    cls_obj.te_name = te_name
    cls_obj.save()
    return True, '老师绑定班级成功'

管理员modles 层

# 类的封装(属性和方法)

# 类的抽取
from db import db_handels

class BaseClass(object):
    # 方法可以将查询方法封装到类中 可以通过类来调用
    # def save()
    def save(self):
        db_handels.db_save(self)

    @classmethod  # 为什么绑定给雷用 因为自动就将类当做第一对象传入 后面拼接路径
    def select(cls, name):
        res = db_handels.db_select(cls, name)
        return res

    # 发封装一个类方法  直接将类作为第一参数传过来
    @classmethod
    def get_all(cls):
        # 获取需要返回到接口层

        list_obj = db_handels.get_all(cls)
        return list_obj

class Admin(BaseClass):
    # 属性 及方法
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
        self.save()

class School(BaseClass):
    def __init__(self,school_name,school_addr):
        self.name = school_name  # 自己的名称空间 优先实列化初始值
        self.addr = school_addr
        self.save()

class Course(BaseClass):
     def __init__(self,name,price,cycle,school_name):
         self.name = name
         self.price = price
         self.cycle = cycle
         self.sc_name = school_name
         self.save()

class Classes(BaseClass):
    def __init__(self,name,course_name, school_name):
        self.name = name
        self.te_name = None  # 暂时还没有老师

        self.sc_name = school_name  # 创建班级需要传学校
        self.c_name = course_name  # 创建班级需要传课程
        self.save()

class Teacher(BaseClass):
    '):
        self.name = te_name
        self.pwd = pwd
        self.sc_name = school_name
        self.c_name = None  # 课程名字哦
        self.save()

class Student(BaseClass):
    def __init__(self, name, pwd, school_name):
        self.name = name
        self.pwd = pwd
        self.sc_name = school_name  # 学校是泥在创建学生要先选的 初始化阶段要进行 实列化传值
        self.class_name = None  # 班级
        self.score = None
        self.is_pay = False  # 是否付费属性
        self.save()

管理员handles 层代码

# 存数据 （对象）
import os
import pickle

from conf import settings

def db_save(obj):  # obj 是save（）自动将对象传过来
    # 拼接路径 判断路径保存

    PATH = os.path.join(settings.DB_PATH, obj.__class__.__name__.lower())

    if not os.path.exists(PATH):
        os.makedirs(PATH)

    path = os.path.join(PATH, obj.name)
    # 将对象写入文件
    with open(path, 'wb')as f:
        pickle.dump(obj, f)
        f.flush()

# 数据处理层
# select() 查询获取
def db_select(cls, name):
    # print(cls,'111')  类
    # 拼接路径主要判断有没有当前路径
    PATH = os.path.join(settings.DB_PATH, cls.__name__.lower())
    # print(PATH, 'path')
    # print(PATH,'4444')

    if not os.path.exists(PATH):
        os.makedirs(PATH)
    # 再判断文件路径
    user_path = os.path.join(PATH, name)
    if not os.path.exists(user_path):
        return
    # print(user_path, 'user_path')
    with open(user_path, 'rb')as f:
        res_obj = pickle.load(f)
        # print(res_obj, 'res_obj')
        return res_obj

# 获取所有对象的类方法
def get_all(cls):
    # 拼接路径
    path = os.path.join(settings.DB_PATH, cls.__name__.lower())
    if not os.path.exists(path):
        return
    # # 拼接文件路径
    # user_path = os.path.join(path, name)
    # with open(user_path, 'rd')
    #拿到当前文件夹下的所有文件

    res = []
    for a in os.listdir(path):  # 这里的a 是 当前path 下的所有文件对象
        # print(names,'names')  #

        # 直接点用select() 拿到返回对象
        obj = db_select(cls, a)  # 调用 数据获取对象
        # print('obj', obj)  # <db.models.School object at 0x000002549D045438> 学校对象

        res.append(obj)  # 将对象添加到列表中
    # print(res,'get_all  111')
    return res  # 返回到models 层

2.老师用户接口层 ：表示层代码

# 教师的功能代码层

from lib import common
from interface import teacher_interface,admin_inerface

current_info = None
current_school = None
def login():
    global current_info, current_school  # 升为全局变量一会记得保存当前用户的登录状态

    while True:
        # 先选择学校
        # 在选择登录
        sc_names = admin_inerface.get_schools_interface()
        sc_name = common.get_name(sc_names, '选择的校区')
        if not sc_name:
            return
        name = input('输入老师名字：').strip()
        pwd = input('输入老师密码：').strip()
        if name and pwd:
            flag, msg = teacher_interface.login_interface(name, pwd,sc_name)
            if flag:
                print(msg)
                current_info = name
                current_school = sc_name
                break
            else:
                print(msg)

# 暂时
def show_class():  # 全部
    """获取这个老师下的班级
    思路：根据当前的学校 和 用户名
    1.先拿到所有的班级 在比对这个老师的是否是这个学校 和这个老师返回一个列表
    2.返回到界循环打印 或者枚举

    :return:
    """
    # 调用接口层
    class_list = teacher_interface.get_classes_list(current_info, current_school)

    if not class_list:
        return '暂无班级列表'
    # 打印 当前的班级列表
    for a in class_list:
        print(class_list.index(a), a)

# 查看当前老师下的学生
def check_student():
    """
    # 拿到所有 的班级 在 在获取 班级下所有的学生

    #

    :return:
    """
    class_list = teacher_interface.get_classes_list(current_info,current_school)
    # 获取班级名字
    cls_name = common.get_name(class_list, '班级名字')
    if not class_list:  # 有班级列表

        return
    # 有则 老师获取所有学生
    stu_dic_list = teacher_interface.get_stu_list_interface(current_school,cls_name)
    if not list:  # 暂时还没有学员
        print('暂时没有学生列表')
        return
    # 在打印字符串拼接 显示个人信息 [{'name':'jason}]
    print('%-8s %-8s %-8s %-8s %-8s'%('name','sc_name','class_name','score','is_pay'))
    for stu_dic in stu_dic_list:

        print('%-8s %-8s %-8s %-8s %-8s '
              %(stu_dic['name'],
                stu_dic['sc_name'],stu_dic['class_name'],stu_dic['score'],
                stu_dic['is_pay']))

# 修改老师密码
def change_pwd():
    """
    对新密码新进限制
    :return:
    """
    new_pwd = input('输入要修改的密码：').strip()
    if len(new_pwd) >=6 and new_pwd.isalnum():
        flag = teacher_interface.change_pwd_interface(current_info,current_school, new_pwd)
        if flag:
            print('密码修改成功')
        else:
            print('修改未成功')

# 修改学生成绩
def change_score():
    """
    需求：修改学生成绩必须获取所有学生 <<< 遍历所有学生 判断 是否当前 学校下的学生和
    1.老师登陆有自己的学校
    2.
    :return:
    """
    # 1.获取班级 当前老师的班级
    cl_list = teacher_interface.get_classes_interface(current_info,current_school)
    cl_name = common.get_name(cl_list, '老师班级')
    if not cl_name:
        return

    # 获取班级下的学生
    students = teacher_interface.get_stu_list_interface(current_school, cl_name)

    if not students:  # 列表套字典
        return '班级下没有学生'

    # 2.获取学生

    stu_name = common.get_name([stu['name'] for stu in students], '学生信息')

    if not stu_name:
        return
    while True:
        score = input('输入修该的分数：').strip()

        if not common.is_number(score):
            print('请输入浮点数')
            continue

        # 调用接口也层修改 解压赋值 一一对应
        flag, msg = teacher_interface.change_score_interface(current_school, stu_name, float(score))
        if flag:
            print(msg)
            break
        else:
            print(msg)

func_dic= {

    ":login,
    ":show_class,
    ":check_student,
    ":change_pwd,
    ":change_score,

}

def teacher_views():
    msg = ("""
    1.登陆
    2.查看班级
    3.查看学员
    4.修改密码
    5.修改成绩
    q.退出

    """)
    common.select_func(func_dic,msg)

老师接口层代码：业务逻辑代码处理层代码

# 教师的功能代码
from db import models

# 老师接口层
def login_interface(name, pwd, sc_name):
    # 直接调用接口层
    te_obj = models.Teacher.select(sc_name+name)
    if not te_obj:
        return False, '用户不存在'
    if pwd == te_obj.pwd:
        return True, '登录成功'

# 获取老师的所有列表
def get_classes_list(te_name, school_name):
    """

    :param te_name:
    :param school_name:
    :return:
    1.先获取这学小的所有列表
    2.循环没有一个班级对象
    3,拿到班级对象点语法可以判断是否等于当前的班级下的学校名字  和当前的班级下的老师名
    4.是直接切分将班级名字返回
    返回一个列表

    """
    # 获取所有班级
    cl_lists = models.Classes.get_all()

    # 循环打印
    res = []
    for a in cl_lists:
        if a.sc_name == school_name and a.te_name == te_name:
            res.append(a.name[len(school_name):])  # 存的时候是有学校的

    return res

# h获取所有的老师
def get_stu_list_interface(current_school,cls_name):
    # 返回
    """

    :param current_school:
    :param cls_name:
    :return: 一个列表存储的是字典
    """
    stu_all_list = models.Student.get_all()
    # print(stu_all_list,'stu_all_list')  # 拿到所有的学生列表对象

    # for 循环
    res = []
    for stu in stu_all_list:
        if stu.sc_name == current_school and stu.class_name == cls_name:

            # 获取学生字典
            stu_dic = stu.__dict__
            stu_dic.pop('pwd')
            # 获取学生的名字
            stu_dic['name'] = stu_dic['name'][len(current_school):]

            res.append(stu_dic)
    return res

# 老师修改密码

def change_pwd_interface(current_info,current_school, new_pwd):
    # 不需要判断了 注意查询老师的时候 拼接查询
    te_obj = models.Teacher.select(current_school+current_info)
    te_obj.pwd = new_pwd
    te_obj.save()
    return True, '修改成功'

# 获取当前老师 的班级
def get_classes_interface(te_name, sc_name):
    # 获取所有
    clas = models.Classes.get_all()

    # 循环
    res = []
    for cl in clas:
        if cl.te_name == te_name and cl.sc_name == sc_name:
            res.append(cl.name[len(sc_name):])
    return res

# 修改学生成绩

def change_score_interface(current_school, stu_name, score):

    # 获取所有学生
    stus = models.Student.get_all()
    ')
    for stu in stus:
        if stu.sc_name == current_school and stu.name == current_school+stu_name:
            stu.score = score
            print(stu.__dict__)
            ')
            stu.save()
            return True, '修改成绩成功'

#
# if __name__ == '__main__':  # 测试代码
#
#     stu = models.Student('rose','123','sh_old')
#     stu.class_name = 'python10'
#     print(stu.__dict__)
#     stu.save()

3.学生用户层：表示层代码

# 学生函数功能层
from lib import common
from interface import admin_inerface,student_inerface

current_school = None
current_info = None
def register():

    # 选择一个校区 在进行注册
    sc_names = admin_inerface.get_schools_interface()
    sc_name = common.get_name(sc_names, '选择校区')
    if not sc_name:
        return
    while True:
        name = input('输入学生名字：').strip()
        pwd = input('输入学生密码：').strip()
        if name and pwd:
            flag, msg = student_inerface.register_interface(sc_name,name,pwd)
            if flag:
                print(msg)
                break
            else:
                print(msg)

def login():
    # 还得选择校区
    global current_school, current_info
    sc_names = admin_inerface.get_schools_interface()
    sc_name = common.get_name(sc_names, '选择校区')
    if not sc_name:
        return
    while True:
        name = input('输入学生名字：').strip()
        pwd = input('输入学生密码：').strip()
        if name and pwd:
            flag, msg = student_inerface.login_interface(sc_name, name, pwd)
            if flag:
                print(msg)
                current_info = name
                current_school = sc_name

                break
            else:
                print(msg)

# 学生缴费
def pay_money():
    """
    1.首先我们要获取这个学生 当前的学生名字  返回一个学生字典 __dict__
    stu =

    2. 判段是否有班级

    3.判断是否缴费

    4。获取当前学生的
    :return:
    """
    while True:
        stu = student_inerface.get_student_interface(current_info, current_school)
        print(stu,'stu')
        if not stu['class_name']:  # 名称字典空间
            # 暂时没有该学生班级
            print('未选择班级')
            return
        if stu['is_pay']:
            print('你已经交过费用了')
            return

    # 获取当前学生的要交的钱是多少

        money = student_inerface.get_money_info(current_info,current_school)
        print('需要缴费金额:[%s]￥' % money)

        cmd = input('输入%s确认缴费<y/n>:').strip()
        if cmd == 'n': break
        elif cmd == 'y':
            flag,msg = student_inerface.pay_money_interface(current_info,current_school)
            if flag:
                print(msg)
            else:
                print(msg)

# 学生选择班级

def choose_classes():
    """
    1.当前由学校名称
    2.获取班级的名字
    3.通过班级赋值
    :return:
    """
    ls_names = student_inerface.get_cls_interface(current_info, current_school)
    ls_name = common.get_name(ls_names,'班级名字')
    ')
    if not ls_name:
        return
    # 有的话则继续
    flag, msg = student_inerface.choose_cls_interface(current_school,current_info,ls_name)
    if flag:
        print(msg)

    else:
        print(msg)

def check_score():
    # 修改分数
    """
    获取学生字典对象
    :return:
    """
    stu_dic = student_inerface.get_student_interface(current_info, current_school)
    if not stu_dic:
        return '暂无学生字典对象'
    print('学生成绩%s' % stu_dic['score'])

func_dic = {
    ":register,
    ":login,
    ":pay_money,
    ":choose_classes,
    ":check_score,
}

def student_views():
    msg = ("""-----欢迎等录学生功能层------
    1、注册
    2、登录
    3、交学费
    4、选择班级
    5、查看成绩
    q、退出 

    """)
    common.select_func(func_dic, msg)

学生层业务逻辑处理层：

# 学生接口层
from db import models

def register_interface(sc_name,name,pwd):
    # 记得拼接
    stu_obj = models.Student.select(sc_name+name)
    if stu_obj:
        return False, '学生已经存在'

    models.Student(sc_name+name, pwd, sc_name)
    print(stu_obj,'stu_obj')
    # stu_obj.save()
    return True, '注册成功'

# 用户登陆

def login_interface(sc_name, name, pwd):
    # 先判断用户名 存在 再判断密码
    stu_obj = models.Student.select(sc_name+name)
    if not stu_obj:
        # 直接返回
        return False, "用户不存在"
    if stu_obj.pwd == pwd:
        return True, '用户登陆成功'

# 获取当前学生信息
def get_student_interface(current_info, current_school):
    stus = models.Student.select(current_school+current_info)

    if stus:
        stu_dic = stus.__dict__
        stu_dic.pop('pwd')
        return stu_dic
    return False

# 获取当前学生要交的学费
def get_money_info(stu_name,sc_name):
    """
    1.获取学生的

    2.获取该学的班级

    3。获取班级取课程对象

    """
    stu = models.Student.select(sc_name+stu_name)

    # 班级对象
    cls = models.Classes.select(sc_name+stu.class_name)  # 获取班级

    # 拿到班级下的课程
    c_course = models.Course.select(sc_name+cls.c_name)

    return c_course.price

# 学生缴费
def pay_money_interface(stu_name,sc_name):
    # 获取学生的缴费信息 改为T
    stu_obj = models.Student.select(sc_name+stu_name)
    stu_obj.is_pay = True
    stu_obj.save()
    return True, '缴费成功'

# 获取班级列表
def get_cls_interface(current_info, current_school):
    cl_list = models.Classes.get_all()

    res = []

    for i in cl_list:
        if i.name.startswith(current_school):
            res.append(i.name[len(current_school):])
    return res

# 给学生添加班级

def choose_cls_interface(current_school,current_info,ls_name):
    stu_obj = models.Student.select(current_school+current_info)
    if not stu_obj:
        return False, '该学生不存在'
    if stu_obj.class_name:  # 一个学生只能选一个班级
        # print('stu_obj',stu_obj.__dict__)
        return False, '已经选则班级'  # 这里是有点问题呀
    stu_obj.class_name = ls_name
    # print(stu_obj.__dict,'2222')
    stu_obj.save()
    return True, '创建班级成功'

4. common 共用功能

# 先封装选择项
from functools import wraps

def select_func(func_dic, msg):
    while True:
        print(msg)
        choice = input('输入功能选项：').strip()
        if choice == 'q':
            break
        elif choice in func_dic:
            func_dic.get(choice)()
        else:

            print('输入有误')

# 获取校区名字
def get_name(names_list, title):
    """

    :param names_list: 管理功能层传过的学校列表
    :param title: 展示给用户的标题 校区  课程 老师 班级
    :return:
    """

    while True:
        if not names_list:
            print('暂时还没有%s'% title)
            return
        # for循环 可以用枚举 这里我们尝试一个新的
        for c_name in names_list:

            print(names_list.index(c_name), c_name)

        choice = input("输入%s编号："% title).strip()

        if not choice.isdigit():
            continue
        choice = int(choice)
        if choice not in range(len(names_list)):
            print('输入的编号不存在')
            continue
        return names_list[choice]

def is_number(score):
    while True:
        try:
            float(score)
            return True
        except BaseException('输入不是浮点数') as e:
            print(e)
            break

# 装饰器
def login_auth(type):

    def outer(func):
        from views import admin, student, teacher
        @wraps(func)

        def inner(*args,**kwargs):
            if type == 'admin':
                module = admin
            elif type == 'student':
                module = student
            elif type == 'teacher':
                module = teacher

            else:
                raise Exception('没有这个模块')
            if module.current_info :
                res = func(*args, **kwargs)
                return res
            else:
                return module.login()
        return inner
    return outer