def __init__(self,
school_name,
city_name,
teachers=None,
courses=None,
students=None,
banjis=None):
'''
定义学校属性
:param school_name: 学校名，字符类型
:param city_name: 城市名，字符类型
:param teachers: 讲师，字典类型，如{"teachers": []}
:param students: 学员, 字典类型，如{"students": []}
:param courses: 课程，字典类型，如{"courses": []}
:param banjis: 班级，字典类型，如{"banjis": []}
'''
self.school_name = school_name
self.city_name = city_name
self.teachers = teachers
self.courses = courses
self.students = students
self.banjis = banjis
self.db = Db(settings.BASE_DATABASE) # 数据库连接
self.db_path = self.db.db_handler()
class BaseDb(object):
'''基础数据库类'''
db = Db(settings.BASE_DATABASE) # 数据库连接
db_path = "%s/base.db" % db.db_handler()
def __init__(self):
'''
初始基础数据课程和学校
'''
if os.path.exists(BaseDb.db_path): # 初始数据库存在时，不做任何操作
return None
# 创建课程3门，linux、python、go课程
go = Course("go", 8000)
linux = Course("linux", 10800)
python = Course("python", 8800)
# 创建学校2所，北京老男孩、上海老男孩
beijing_oldboy_school = School("beijing_oldboy_school", "beijing",
{"teachers": []},
{"courses": [linux, python]},
{"students": []}, {"banjis": []})
shanghai_oldboy_school = School("shanghai_oldboy_school", "shanghai",
{"teachers": []}, {"courses": [go]},
{"students": []}, {"banjis": []})
base_data = {
"schools": [beijing_oldboy_school, shanghai_oldboy_school],
}
self.save_data(base_data)
admin_username = "******"
admin_password = "******"
status = 1
authority = 8
admin = Admin(admin_username, admin_password, status, authority)
admin.create()
def save_data(self, base_data):
'''保存基础数据库
:param base_data: 基础数据
:return
'''
BaseDb.db.dump_pickle_data(BaseDb.db_path, base_data) # 写入数据库
return True
def get_data(self):
base_data = BaseDb.db.load_pickle_data(BaseDb.db_path)
# 从数据库读取学员信息
schools = base_data["schools"]
attr_students = "students"
attr_teachers = "teachers"
for school in schools:
students = getattr(school, attr_students)[attr_students]
teachers = getattr(school, attr_teachers)[attr_teachers]
for student in students:
account_id = student.account.account_id
student.account = student.account.get_account_data(account_id)
user_info_dict = student.account.user_info
student.name = user_info_dict.get("name")
student.sex = user_info_dict.get("sex")
student.age = user_info_dict.get("age")
for teacher in teachers:
account_id = teacher.account.account_id
teacher.account = teacher.account.get_account_data(account_id)
user_info_dict = teacher.account.user_info
teacher.name = user_info_dict.get("name")
teacher.sex = user_info_dict.get("sex")
teacher.age = user_info_dict.get("age")
return base_data
def __init__(self):
General.__init__(self)
self.conn = self.pool.connection()
self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)
self.db = Db(self.conn, self.cursor)
class Account(object):
'''
帐号类
'''
db = Db(settings.ACCOUNT_DATABASE) # 数据库连接，公共属性
db_path = db.db_handler()
def __init__(self,
user_name,
password,
status=settings.STATUS['normal'],
authority=settings.AUTHORITY['student'],
user_info={}):
'''
定义帐号属性
:param user_name: 用户名, 字符类型
:param password: 密码, 字符类型
:param status: 帐号状态和帐号权限，数字整型
:param authority: 帐号权限, 数字整型
:param user_info: 用户信息, 字典类型
'''
self.user_name = user_name
self.password = password
self.status = status # 0为锁定用户，1为正常
self.authority = authority # 1为普通用户（学员），2为讲师，8为admin用户
self.user_info = user_info # 学员、讲师、学校信息
def show_info(self):
'''查看user_info属性'''
print("account_id: \033[32;1m{}\033[0m".format(self.account_id))
if self.user_info:
for k in self.user_info:
print("{}: \033[32;1m{}\033[0m".format(k, self.user_info[k]))
def create(self):
'''
创建新帐号
:return: 返回帐户实例（自己））
'''
# 获取自增长id
begin_id = 10000
auto_increment_file = "%s/increment_id" % os.path.dirname(
Account.db_path)
if os.path.exists(auto_increment_file): # 自增长id文件存在时
line = Account.db.load_pickle_data(auto_increment_file)
auto_increment_id = int(line) + 1
else: # 自增长id文件不存在时
id_list = [] # 帐户数据文件
files_list = os.listdir(Account.db_path)
for f in files_list:
exist_flag = re.match(r'^(\d{5,})', f)
if exist_flag: # 有帐户存在时
id_list.append(f)
if id_list:
id_list.sort()
max_id = int(id_list[-1])
auto_increment_id = max_id + 1
else:
auto_increment_id = begin_id # 帐户数据文件不存在
self.account_id = auto_increment_id # 帐户id
check_flag = self.check_user_name(auto_increment_id) # 检查用户名
user_file = "%s/%s" % (Account.db_path, auto_increment_id)
if not check_flag: # 用户名不存在，才创建用户
Account.db.dump_pickle_data(auto_increment_file,
auto_increment_id) # 保存自增加id
Account.db.dump_pickle_data(user_file, self) # 保存帐户数据
return self
else:
print("User name [\033[31;1m%s\033[0m] has been registered!" %
self.user_name)
return False
def check_user_name(self, account_id):
'''
用account_id检查用户名是否存在于数据库
:param user_name: 用户名，字符类型
:return: 存在则为真，否则为假
'''
user_names = [] # 初始化用户名数据库
exist_flag = False # 初始化存在标记
user_names_file = "%s/user_names" % Account.db_path
if os.path.exists(user_names_file):
user_names = Account.db.load_pickle_data(user_names_file)
for u_n in user_names:
if u_n["user_name"] == self.user_name: # 存在
exist_flag = u_n["account_id"]
return exist_flag
user_names.append({
"account_id": account_id,
"user_name": self.user_name
})
result = Account.db.dump_pickle_data(user_names_file, user_names)
return exist_flag
def get_account_id(self, user_name):
'''
用user_name查询出account_id
:return:
'''
exist_flag = False # 初始化存在标记
user_names_file = "%s/user_names" % Account.db_path
if os.path.exists(user_names_file):
user_names = Account.db.load_pickle_data(user_names_file) # 列表类型
for u_n in user_names:
if u_n["user_name"] == user_name: # 存在
exist_flag = u_n["account_id"]
return exist_flag
# print("User name [\033[31;1m%s\033[0m] does not exist!" % user_name)
return exist_flag
def get_account_data(self, account_id):
'''获取帐户数据
:param account_id: 帐户id
'''
exist_flag = False # 初始化存在标记
user_file = "%s/%s" % (Account.db_path, account_id)
if os.path.exists(user_file):
account = Account.db.load_pickle_data(user_file)
account_data = {
"account_id": account_id,
"user_name": self.user_name,
"password": self.password,
"status": self.status,
"authority": self.authority,
"user_info": self.user_info
}
return account
# print("Account [\033[31;1m%s\033[0m] does not exist!" % account_id)
return exist_flag
def save_data(self, account_id):
'''保存数据至数据库
:param account_id: 帐户id
'''
user_file = "%s/%s" % (Account.db_path, account_id)
Account.db.dump_pickle_data(user_file, self) # 保存帐户数据
return True
def login(self):
'''登录
因为用户输入的是用户名，需要转化成account_id来验证
'''
account_id = self.get_account_id(self.user_name) # 获取account_id
if account_id:
account_data = self.get_account_data(account_id)
user_file = "%s/%s" % (Account.db_path, account_id)
if os.path.exists(user_file):
account = Account.db.load_pickle_data(user_file) # 获取用户帐户
if account.password == self.password: # 验证密码
if self.status == settings.STATUS['normal']:
return account # 返回帐户实例
else:
print(
"Account locked,[\033[31;1m%s\033[0m] sign in failed!"
% self.user_name)
else:
print(
"Password error,[\033[31;1m%s\033[0m] sign in failed!"
% self.user_name)
return False
else:
print("Account [\033[31;1m%s\033[0m] data exception!" %
account_id)
else:
print("User name [\033[31;1m%s\033[0m] does not exist!" %
self.user_name)
class Account(object):
'''
账号信息
'''
db = Db(settings.ACCOUNT_DATABASE) # 数据库连接，公共属性
db_path = db.db_handler()
def __init__(self,
user_name,
password,
status=settings.STATUS['normal'],
authority=settings.AUTHORITY['student'],
user_info={}):
'''
定义账号属性
:param user_name: 用户名，字符属性
:param password: 密码，字符属性
:param status: 账号状态，整数类型
:param authority: 账号权限，整数类型
:param user_info: 用户信息，字典类型
'''
self.user_name = user_name
self.password = password
self.status = status
self.authority = authority
self.user_info = user_info
def show_info(self):
'''查看user_info属性'''
print("account_id: \033[32;1m{}\033[0m".format(self.account_id))
if self.user_info:
for k in self.user_info:
print("{}: \033[32;1m{}\033[0m".format(k, self.user_info[k]))
def create(self):
'''
创建新账号
:return: 账户实例
'''
# 获取自增长id
begin_id = 10000
auto_increment_file = "%s/increment_id" % os.path.dirname(
Account.db_path)
if os.path.exists(auto_increment_file):
line = Account.db.load_pickle_data(auto_increment_file)
auto_increment_id = int(line) + 1
else: # 自增长id文件不存在
id_list = []
files_list = os.listdir(Account.db_path)
for f in files_list:
exist_flag = re.match(r'^(\d{5,})', f)
if exist_flag:
id_list.append(f)
if id_list:
id_list.sort()
max_id = int(id_list[-1])
auto_increment_id = max_id + 1
else:
auto_increment_id = begin_id
self.account_id = auto_increment_id
check_flag = self.check_user_name(auto_increment_id)
if not check_flag: # 用户名不存在，才创建用户
user_file = "%s/%s" % (Account.db_path, auto_increment_id)
Account.db.dump_pickle_data(auto_increment_file, auto_increment_id)
Account.db.dump_pickle_data(user_file, self)
return self
else:
print("User name [\033[31;1m%s\033[0m] has been registered!" %
self.user_name)
return False
def check_user_name(self, account_id):
'''
查询数据库用户名是否存在
:param account_id: 用户名，字符类型
:return: True 存在，False 不存在
'''
user_names = [] # 初始化用户名数据库
exist_flag = False # 初始存在标记
user_names_file = "%s/user_names" % Account.db_path
if os.path.exists(user_names_file):
user_names = Account.db.load_pickle_data(user_names_file)
for usr in user_names:
if usr["user_name"] == self.user_name:
exist_flag = usr["account_id"]
return exist_flag
user_names.append({
"account_id": account_id,
"user_name": self.user_name
})
Account.db.dump_pickle_data(user_names_file, user_names)
@staticmethod
def get_account_data(account_id):
'''
获取账户数据
:param account_id: 账户id
:return:
'''
exist_flag = False
user_file = "%s/%s" % (Account.db_path, account_id)
if os.path.exists(user_file):
account = Account.db.load_pickle_data(user_file)
return account
print("Account [\033[31;1m%s\033[0m] does not exist!" % account_id)
return exist_flag
@staticmethod
def get_account_id(user_name):
'''
用user_name查询出account_id
:param user_name:
:return:
'''
exist_flag = False
user_name_file = "%s/user_names" % Account.db_path
if os.path.exists(user_name_file):
user_names = Account.db.load_pickle_data(
user_name_file) # 获取用户名：id 的列表数据
for u_n in user_names:
if u_n['user_name'] == user_name:
exist_flag = u_n['account_id']
return exist_flag
print("User name [\033[31;1m%s\033[0m] does not exist!" % user_name)
return exist_flag
def save_data(self, account_id):
'''保存数据至数据库
:param account_id: 帐户id
'''
user_file = "%s/%s" % (Account.db_path, account_id)
Account.db.dump_pickle_data(user_file, self) # 保存帐户数据
def login(self):
'''
用户输入的是账号，通过账号获取account_id验证登录
:return: 账号实例
'''
account_id = self.get_account_id(self.user_name)
if account_id:
account = self.get_account_data(account_id)
if account.password == self.password:
if self.status == settings.STATUS['normal']:
return account
else:
print(
"Account locked, [\033[31;1m%s\033[0m] sign in failed!"
% self.user_name)
return False
else:
print("Password error, [\033[31;1m%s\033[0m] sign in failed!" %
self.user_name)
return False
else:
print("User name [\033[31;1m%s\033[0m] does not exist!" %
self.user_name)
return False
class BaseDb(object):
'''基础数据库类'''
db = Db(settings.BASE_DATABASE)
db_path = "%s/base.db" % db.db_handler()
def __init__(self):
'''
初始化基础数据课程和学校
'''
if os.path.exists(BaseDb.db_path): # 初始数据库存在时，不做任何操作
return None
# 创建课程
java = Course("java", 8000)
linux = Course("linux", 10300)
python = Course("python", 12000)
# 创建学校两所，北京An，上海An
beijing_an_school = School("beijing_an_school", "beijing",
{"teachers": []},
{"courses": [java, linux]},
{"students": []}, {"grades": []})
shanghai_an_school = School("shanghai_an_school", "shanghai",
{"teachers": []},
{"courses": [java, python]},
{"students": []}, {"grades": []})
base_data = {"schools": [beijing_an_school, shanghai_an_school]}
self.save_data(base_data)
admin_username = '******'
admin_password = '******'
status = 1
authority = 9
admin = Admin(admin_username, admin_password, status, authority)
admin.create()
@staticmethod
def save_data(base_data):
'''
保存基础数据库
:param base_data: 基础数据
:return:
'''
BaseDb.db.dump_pickle_data(BaseDb.db_path, base_data)
@staticmethod
def get_data():
base_data = BaseDb.db.load_pickle_data(BaseDb.db_path)
# 从文件中读取信息
schools = base_data['schools']
attr_students = 'students'
attr_teachers = 'teachers'
for school in schools:
students = getattr(school, attr_students)[attr_students]
teachers = getattr(school, attr_teachers)[attr_teachers]
for student in students:
account_id = student.account.account_id
student.account = student.account.get_account_data(account_id)
user_info_dict = student.account.user_info
student.name = user_info_dict.get['name']
student.sex = user_info_dict.get['sex']
student.age = user_info_dict.get['age']
for teacher in teachers:
account_id = teacher.account.account_id
teacher.account = teacher.account.get_account_data(account_id)
user_info_dict = teacher.account.user_info
teacher.name = user_info_dict.get['name']
teacher.sex = user_info_dict.get['sex']
teacher.age = user_info_dict.get['age']
return base_data
class Account(object):
'''
账号类
'''
db = Db(settings.ACCOUNT_DATABASE) #数据库连接,公共属性
db_path = db.db_handler()
def __init__(self,
user_name,
password,
status=settings.STATUS['normal'],
authority=settings.AUTHORITY['student'],
user_info={}):
'''
定义账号属性
:param user_name: 用户名，字符类型
:param password: 密码，字条类型
:param status: 账号状态和账号账号权限，数字整形
:param authority: 账号权限，数字整型
:param user_info: 用户信息，字典类型
'''
self.user_name = user_name
self.password = password
self.status = status #0为锁定用户,1为正常
self.authority = authority #1为普通学员,2为讲师,8为admin用户
self.user_info = user_info #学员、讲师、学校信息
def show_info(self):
'''查看user_info属性'''
print("account_id: \033\[32;1m{}\033[0m".format(self.account_id))
if self.user_info:
for k in self.user_info:
print("{}: \033\[32;1m{}\033[0m".format(k, self.user_info[k]))
def create(self):
'''
创建新账号
:return: 返回账户实例(自己)
'''
#获取自增长ID
begin_id = 10000
auth_increment_file = "%s/increment_id" % os.path.dirname(
Account.db_path)
if os.path.exists(auth_increment_file): #自增长id文件存在时
line = Account.db.load_pickle_date(auth_increment_file)
auth_increment_id = int(line) + 1
else: #自增长id文件不存在时
id_list = [] #账户数据文件
files_list = os.listdir(Account.db_path)
for f in files_list:
exist_flag = re.match(r'^(\d{5,})', f)
if exist_flag: #有账号存在时
id_list.append(f)
if id_list:
id_list.sort()
max_id = int(id_list[-1])
auto_increment_id = max_id + 1
else:
auto_increment_id = begin_id #账号数据不存在
self.account_id = auto_increment_id #账号ID
check_flag = self.check_user_name(auto_increment_id) #检查用户名是否存在
user_file = "%s/%s" % (Account.db_path, auto_increment_id)
if not check_flag: #用户名不存在,才创建用户
Account.db.dump_pickle_data(auth_increment_file, auth_increment_id)
Account.db.dump_pickle_data(user_file, self) #保存账户数据,后面的self暂不是很明白
return self
else:
print("User name [\033[31;1m%s\033[0m] has been registered!" %
self.account_id)
return self
def check_user_name(self, account_id):
'''
用account_id 检查用户名是否存在于数据库
:param account_id: 用户名,字符类型
:return: 存在则为真,否则为假
'''
user_names = [] # 初始化用户名数据库
exist_flag = False # 初始化存在标记
user_names_file = "%s/user_names" % Account.db_path
if os.path.exists(user_names_file):
user_names = Account.db.load_pickle_date(user_names_file)
for u_n in user_names:
if u_n["user_name"] == self.user_name: #存在
exist_flag = u_n["account_id"]
return exist_flag
user_names.append({
"account_id": account_id,
"user_names": self.user_name
})
result = Account.db.dump_pickle_data(user_names_file, user_names)
return exist_flag
def get_account_id(self, user_name):
'''
用user_name 查询出account_id
:param user_name:
:return:
'''
exist_flag = False #初始化存在标记
user_names_file = "%s/user_names" % Account.db_path
if os.path.exists(user_names_file):
user_names = Account.db.load_pickle_date(user_names_file)
for u_n in user_names:
if u_n["user_name"] == user_name: #存在
exist_flag = u_n["account_id"]
return exist_flag
return exist_flag
def get_account_data(self, account_id):
'''
获取账号数据
:param account_id: 账户id
:return:
'''
exist_flag = False #初始化存在标记
user_file = "%s/%s" % (Account.db_path, account_id)
if os.path.exists(user_file):
account = Account.db.load_pickle_date(user_file)
account_data = {
"account_id": account_id,
"user_name": self.user_name,
"password": self.password,
"status": self.status,
"authority": self.authority,
"user_info": self.user_info
}
return account
return exist_flag
def save_data(self, account_id):
'''
保存数据到数据库
:param account_id: 账户id
:return:
'''
user_file = "%s/%s" % (Account.db_path, account_id)
Account.db.dump_pickle_data(user_file, self) #保存账号数据
return True
def login(self):
'''
登录
因为用户名输入的是用户名，需要转化成account_id来验证
:return:
'''
account_id = self.get_account_data(self.user_name)
if account_id:
account_data = self.get_account_data(account_id)
user_file = "%s/%s" % (Account.db_path, account_id)
if os.path.exists(user_file):
account = Account.db.load_pickle_date(user_file) #获取用户账号
if account.password == self.password: #验证密码
if self.status == settings.STATUS['normal']:
return account #返回账号实例
else:
print(
"Account locked,[\033[31;1m %s \033[0m] sign in failed !"
% self.user_name)
else:
print(
"Password error,[\033[31;1m %s \033[0m] sign in failed !"
% self.user_name)
return False
else:
print("Account [\033[31;1m %s \033[0m] data exception " %
account_id)
else:
print("User name [\033[31;1m %s \033[0m]" % self.user_name)
