def model_lesson_vote(cls,
ctx: bool = True,
lesson_id: str = 0,
vote: bool = True):
model_lesson = dao.ModelLesson.get_model_lesson_by_lesson_id(
query_dict={'lesson_id': lesson_id}, unscoped=False)
if model_lesson is None:
raise CustomError(404, 404, 'model_lesson not found')
lesson = dao.Lesson.get_lesson(
query_dict={'lesson_id': model_lesson['lesson_id']},
unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
try:
if vote:
dao.ModelLesson.update_model_lesson(
ctx=False,
query_dict={'lesson_id': [lesson_id]},
data={'votes': int(model_lesson['votes']) + 1})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_model_lesson(cls, ctx: bool = True, id: int = 0):
model_lesson = dao.ModelLesson.get_model_lesson(query_dict={'id': id},
unscoped=False)
if model_lesson is None:
raise CustomError(404, 404, 'model_lesson not found')
lesson = dao.Lesson.get_lesson(
query_dict={'lesson_id': model_lesson['lesson_id']},
unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
try:
dao.ModelLesson.delete_model_lesson(ctx=False,
query_dict={'id': [id]})
dao.Lesson.update_lesson(
ctx=False,
query_dict={'lesson_id': [model_lesson['lesson_id']]},
data={'lesson_model': ''})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def update_lesson(cls, ctx: bool = True, lesson_id: str = 0, data: dict = None):
from app.core.controller import NoticeLessonController
if data is None:
data = dict()
if 'id' in data:
del data['id']
lesson = dao.Lesson.get_lesson(query_dict={'lesson_id':lesson_id}, unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
lesson_level = data.get('lesson_level', None)
if lesson_level is not None and lesson_level == '关注课程':
notice_lesson_data = dict()
notice_lesson_data['term'] = lesson['term']
notice_lesson_data['group_name'] = data['group_name']
notice_lesson_data['lesson_attention_reason'] = data['lesson_attention_reason']
notice_lesson_data['lesson_id'] = lesson['lesson_id']
NoticeLessonController.insert_notice_lesson(ctx=False, data=notice_lesson_data)
try:
dao.Lesson.update_lesson(ctx=ctx, query_dict={'lesson_id': [lesson_id]}, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_notice_lesson(cls, ctx: bool = True, lesson_teacher_id: int = 0):
notice_lesson_teacher = dao.NoticeLesson.get_notice_lesson(
query_dict={'lesson_teacher_id': lesson_teacher_id}, unscoped=False)
if notice_lesson_teacher is None:
raise CustomError(404, 404, 'notice_lesson_teacher not found')
try:
lessons,total = dao.Lesson.query_lessons(
query_dict={'lesson_teacher_id': notice_lesson_teacher['lesson_teacher_id']}, unscoped=False)
if lessons is None:
raise CustomError(404, 404, 'lesson not found')
dao.NoticeLesson.delete_notice_lesson(
ctx=False, query_dict={'lesson_teacher_id': [lesson_teacher_id]})
for lesson in lessons:
dao.Lesson.update_lesson(ctx=False, query_dict={'lesson_teacher_id': [lesson['lesson_teacher_id']]},
data={'lesson_level': '自主听课'})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_notice_lessons(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
notice_lesson_ids = data.get('notice_lesson_ids', [])
try:
for notice_lesson_id in notice_lesson_ids:
notice_lesson = dao.NoticeLesson.get_notice_lesson(
query_dict={'id': notice_lesson_id}, unscoped=False)
if notice_lesson is None:
raise CustomError(404, 404, 'notice_lesson not found')
lesson = dao.Lesson.get_lesson(
query_dict={'lesson_id': notice_lesson['lesson_id']},
unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
dao.NoticeLesson.delete_notice_lesson(
ctx=False, query_dict={'id': [notice_lesson_id]})
dao.Lesson.update_lesson(
ctx=False,
query_dict={'lesson_id': [notice_lesson['lesson_id']]},
data={'lesson_level': '自助听课'})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def update_activity_user(cls, ctx: bool = True, activity_id: int = 0, username: str = None, data: dict = None):
if data is None:
data = {}
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, 'user not found')
activity = dao.Activity.get_activity(query_dict={'id': activity_id}, unscoped=False)
if activity is None:
raise CustomError(404, 404, 'activity not found')
activity_user = dao.ActivityUser.get_activity_user(
query_dict={'activity_id': activity_id, 'username': username}, unscoped=False)
if activity_user is None:
raise CustomError(404, 404, 'activity_user not found')
new_data = dict()
for key, value in data.items():
if key not in ['username', 'activity_id', 'username']:
new_data[key] = value
try:
dao.ActivityUser.update_activity_user(ctx=False,
query_dict={'activity_id': [activity_id], 'username': [username]},
data=new_data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_lesson_record(cls,
ctx: bool = True,
username: str = None,
term: str = None):
if term is None:
term = service.TermService.get_now_term()['name']
lesson_record = dao.LessonRecord.get_lesson_record(query_dict={
'username': username,
'term': term
},
unscoped=False)
if lesson_record is None:
raise CustomError(404, 404, 'lesson_record not found')
try:
dao.LessonRecord.delete_lesson_record(
ctx=False, query_dict={'id': [lesson_record['id']]})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def export_lesson_excel(cls, data: dict = None):
if data is None:
data = dict()
if 'term' in data:
notice_lessons, num = dao.NoticeLesson.query_notice_lessons(query_dict={'term': [data['term']]})
else:
notice_lessons, num = dao.NoticeLesson.query_notice_lessons()
column_dict = {'课程名称': 'lesson_name', '课程性质': 'lesson_attribute', '学分': 'lesson_grade', '开课学年': 'lesson_year',
'开课学期': 'lesson_semester', '任课教师名称': 'lesson_teacher_name', '任课教师所在学院': 'lesson_teacher_unit',
'指定小组': 'group_name', '关注原因': 'lesson_attention_reason', '关注次数': 'notices'}
frame_dict = dict()
for notice_lesson in notice_lessons:
lesson = dao.Lesson.get_lesson(query_dict={'lesson_id':notice_lesson['lesson_id']}, unscoped=True)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
for key, value in column_dict.items():
excel_value = lesson[value] if value in lesson else notice_lesson.get(value, "")
if key not in frame_dict:
frame_dict[key] = [excel_value]
else:
frame_dict[key].append(excel_value)
try:
frame = pandas.DataFrame(frame_dict)
from app import basedir
filename = '/static/' + datetime.datetime.now().strftime('%Y%m%d%H%M%S') + '.xlsx'
fullname = basedir + filename
frame.to_excel(fullname, sheet_name='123', index=False, header=True)
except Exception as e:
raise CustomError(500, 500, str(e))
return filename
def update_lesson_record(cls,
ctx: bool = True,
username: str = None,
term: str = None,
data: dict = None):
if data is None:
data = {}
lesson_record = dao.LessonRecord.get_lesson_record(query_dict={
'username': username,
'term': term
},
unscoped=False)
if lesson_record is None:
raise CustomError(404, 404, 'lesson_record not found')
try:
dao.LessonRecord.update_lesson_record(
query_dict={'id': [lesson_record['id']]}, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def insert_lesson_record(cls, ctx: bool = True, data: dict = None):
if data is None:
data = {}
data = cls.reformatter_insert(data)
username = data.get('username', None)
term = data.get('term', service.TermService.get_now_term()['name'])
user = dao.User.get_user(query_dict={'username': username},
unscoped=False)
if user is None:
raise CustomError(404, 404, 'lesson_record not found')
supervisor = dao.Supervisor.get_supervisor(query_dict={
'username': username,
'term': term
},
unscoped=False)
if supervisor is None:
raise CustomError(404, 404, 'supervisor not found')
try:
data = {
'username': username,
'term': term,
'name': user['name'],
'group_name': supervisor['group_name']
}
dao.LessonRecord.insert_lesson_record(ctx=False, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def update_consult_type(cls,
ctx: bool = True,
id: int = 0,
data: dict = None):
if data is None:
data = {}
data = cls.reformatter_update(data)
consult_type = dao.ConsultType.get_consult_type(query_dict={'id': id},
unscoped=False)
if consult_type is None:
raise CustomError(404, 404, 'consult_type not found')
try:
dao.ConsultType.update_consult_type(ctx=False,
query_dict={'id': [id]},
data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def insert_notice_lesson(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
data['term'] = data.get('term', service.TermService.get_now_term()['name'])
data = cls.reformatter_insert(data=data)
lesson = dao.Lesson.get_lesson(query_dict={'lesson_id':data['lesson_id']}, unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
try:
(notice_lesson_records, num) = dao.NoticeLesson.query_notice_lessons(
query_dict={'lesson_id': [data['lesson_id']], 'term': [data['term']]}, unscoped=False)
if num > 0:
raise CustomError(500, 200, 'lesson has been noticed')
dao.NoticeLesson.insert_notice_lesson(ctx=False, data=data)
dao.Lesson.update_lesson(ctx=False, query_dict={'lesson_id': [data['lesson_id']]},
data={'lesson_level': '关注课程'})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def insert_notice_lessons(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
data['term'] = data.get('term', service.TermService.get_now_term()['name'])
lesson_ids = data.get('lesson_ids', [])
try:
for lesson_id in lesson_ids:
lesson = dao.Lesson.get_lesson(query_dict={'lesson_id':lesson_id}, unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
(_, num) = dao.NoticeLesson.query_notice_lessons(query_dict={'lesson_id': [lesson_id]}, unscoped=False)
if num != 0:
continue
data['lesson_id'] = lesson_id
data = cls.reformatter_insert(data)
dao.NoticeLesson.insert_notice_lesson(ctx=False, data=data)
dao.Lesson.update_lesson(ctx=False, query_dict={'lesson_id': [lesson_id]},
data={'lesson_level': '关注课程'})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def reformatter(cls, data: dict):
new_data = dict()
must_columns = ['apply_start_time', 'apply_end_time', 'start_time', 'end_time']
for must_column in must_columns:
if must_column not in data:
raise CustomError(200, 500, must_column + ' not found')
for key, value in data.items():
if key not in ['state', 'apply_state', 'attend_num', 'remainder_num']:
new_data[key] = value
apply_start_time = data.get('apply_start_time', None)
apply_end_time = data.get('apply_end_time', None)
start_time = data.get('start_time', None)
end_time = data.get('end_time', None)
if apply_start_time > apply_end_time:
raise CustomError(200, 500, 'apply_start_time can not be after apply_end_time')
if start_time > end_time:
raise CustomError(200, 500, 'start_time can not be after end_time')
if apply_end_time > start_time:
raise CustomError(200, 500, 'apply_end_time can not be after start_time')
now = datetime.now()
if str(now) > apply_end_time:
new_data['apply_state'] = '报名已结束'
elif str(now) < apply_start_time:
new_data['apply_state'] = '报名未开始'
else:
new_data['apply_state'] = '报名进行中'
if str(now) > end_time:
new_data['state'] = '活动已结束'
elif str(now) < start_time:
new_data['state'] = '活动未开始'
else:
new_data['state'] = '活动进行中'
new_data['attend_num'] = 0
new_data['remainder_num'] = data['all_num']
return new_data
def update_grouper(cls, ctx: bool = True, username: str = None, term: str = None, group_name: str = None,
role_name: str = None, add: bool = False):
(supervisors, num) = dao.Supervisor.query_supervisors(query_dict={'username': [username], 'term_gte': [term]})
if num == 0:
raise CustomError(500, 200, 'user must be supervisor')
try:
if group_name is None:
dao.Supervisor.update_supervisor(ctx=False, query_dict={'username': [username], 'term_gte': [term]},
data={role_name: add})
else:
dao.Supervisor.update_supervisor(ctx=False, query_dict={'username': [username], 'term_gte': [term]},
data={role_name: add, 'group_name': group_name})
if add:
dao.Group.update_group(ctx=False, query_dict={'name': [group_name]}, data={'leader_name': [username]})
else:
dao.Group.update_group(ctx=False, query_dict={'name': [group_name]}, data={'leader_name': ['']})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, err_info=str(e))
return True
def update_user(cls, ctx: bool = True, username: str = '', data: dict = None):
if data is None:
data = dict()
try:
data['term'] = data.get('term', service.TermService.get_now_term()['name'])
if username is None:
raise CustomError(500, 500, 'username or role_names should be given')
term = data['term']
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, 'user is not found')
role_names = data.get('role_names', [])
role_name_dict = {'管理员': 'is_admin', '学院领导': 'is_leader','校级管理员':'is_reader','教发管理员':'is_develop'}
for role_name in role_name_dict.keys():
role_name_filed = role_name_dict[role_name]
data[role_name_filed] = True if role_name in role_names else False
dao.User.update_user(ctx=False, username=username, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, err_info=str(e))
return True
def delete_activity_user(cls, ctx: bool = True, activity_id: int = 0, username: str = None):
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, 'user not found')
activity = dao.Activity.get_activity(query_dict={'id': activity_id}, unscoped=False)
if activity is None:
raise CustomError(404, 404, 'activity not found')
activity_user = dao.ActivityUser.get_activity_user(
query_dict={'activity_id': activity_id, 'username': username}, unscoped=False)
if activity_user is None:
raise CustomError(404, 404, 'activity_user not found')
attend_num = activity['attend_num'] - 1
remainder_num = activity_id['remainder_num'] + 1
try:
dao.ActivityUser.delete_activity_user(ctx=False, query_dict={'id': [activity_user['id']]})
dao.Activity.update_activity(ctx=False, query_dict={'id': [activity_id]},
data={'attend_num': attend_num, 'remainder_num': remainder_num})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_supervisor(cls,
ctx: bool = True,
username: str = '',
term: str = None):
if term is None:
term = service.TermService.get_now_term()['name']
user = dao.User.get_user(query_dict={'username': username},
unscoped=False)
if user is None:
raise CustomError(404, 404, 'user is not found')
try:
dao.User.update_user(ctx=False,
username=username,
data={'is_guider': False})
dao.Supervisor.delete_supervisor(ctx=False,
query_dict={
'username': [username],
'term_gte': [term]
})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def insert_model_lesson(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
term = data.get('term', service.TermService.get_now_term()['name'])
data['term'] = term
data = cls.reformatter_insert(data=data)
lesson = dao.Lesson.get_lesson(query_dict={'lesson_id': data['lesson_id']}, unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
status = data.get('status', '推荐为好评课')
lesson_id = data.get('lesson_id', None)
if lesson_id is None:
raise CustomError(500, 200, 'lesson_id must be given')
try:
(_, num) = dao.ModelLesson.query_model_lessons(query_dict={'lesson_id': [lesson_id]}, unscoped=False)
if num != 0:
raise CustomError(500, 200, 'lesson has been model lesson')
data['unit'] = lesson['lesson_unit']
data['lesson_name'] = lesson['lesson_name']
data['lesson_teacher_name'] = lesson['lesson_teacher_name']
dao.ModelLesson.insert_model_lesson(ctx=False, data=data)
dao.Lesson.update_lesson(ctx=False, query_dict={'lesson_id': [data['lesson_id']]},
data={'lesson_model': status})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def notice_lesson_vote(cls, ctx: bool = True, id: int = 0):
notice_lesson = dao.NoticeLesson.get_notice_lesson(
query_dict={'id': id}, unscoped=False)
if notice_lesson is None:
raise CustomError(404, 404, 'notice_lesson not found')
lesson = dao.Lesson.get_lesson(
query_dict={'lesson_id': notice_lesson['lesson_id']},
unscoped=False)
if lesson is None:
raise CustomError(404, 404, 'lesson not found')
try:
dao.Lesson.update_lesson(
ctx=False,
query_dict={'lesson_id': notice_lesson['lesson_id']},
data={'notices': int(lesson['notices'] + 1)})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def reformatter_insert(cls, data: dict):
if 'lesson_id' not in data:
raise CustomError(500, 200, 'lesson id should be given')
if 'group_name' not in data:
raise CustomError(500, 200, 'group name should be given')
if 'lesson_attention_reason' not in data:
raise CustomError(500, 200, 'notice reason should be given')
return data
def insert_supervisor(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
username = data.get('username', None)
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, 'user is not found')
term = data.get('term', service.TermService.get_now_term()['name'])
data['name'] = user['name']
data['unit']= user['unit']
(_, num) = dao.Supervisor.query_supervisors(query_dict={'username': [username], 'term': [term]}, unscoped=False)
if num != 0:
raise CustomError(500, 200, 'user has been supervisor')
if username is None:
raise CustomError(500, 200, 'username should be given')
if term is None:
term = service.TermService.get_now_term()['name']
try:
grouper = data.get('is_grouper', False)
main_grouper = data.get('is_main_grouper', False)
if grouper:
dao.Supervisor.update_supervisor(
query_dict={'group_name': [data.get('group_name')], 'term_gte': [term], 'grouper': [True]},
data={'grouper': False})
# 如果加入的督导是大组长，那么找到原有的大组长，将main_grouper设为false,即原有大组长身份消失
# if main_grouper:
# dao.Supervisor.update_supervisor(
# query_dict={'term_gte': [term], 'main_grouper': [True]},
# data={'main_grouper': False})
dao.User.update_user(ctx=False, username=username, data={'is_guider': True})
school_term = SchoolTerm(term)
data['grouper'] = grouper
data['main_grouper'] = main_grouper
for i in range(0, 4):
data['term'] = school_term.term_name
(_, num) = dao.Term.query_terms(query_dict={'name': [school_term.term_name]})
if num == 0:
dao.Term.insert_term(ctx=False, data={'name': school_term.term_name})
dao.Supervisor.insert_supervisor(ctx=False, data=data)
lesson_record_data = {'username': username, 'term': school_term.term_name,
'group_name': data['group_name'],
'name': user['name']}
dao.LessonRecord.insert_lesson_record(ctx=False, data=lesson_record_data)
school_term = school_term + 1
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, err_info=str(e))
return True
def login(cls, username: str, password: str):
if username is None or password is None:
raise CustomError(403, 403, '用户名或密码错误')
try:
dao.User.login(username=username, password=password)
except Exception as e:
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, err_info=str(e))
return True
def batch_renewal(cls, ctx: bool = True, data: dict = None):
if data is None:
data = dict()
usernames = data.get('usernames', None)
term = data.get('term', None)
if usernames is None:
raise CustomError(500, 500, 'usernames should be given')
if term is None:
term = service.TermService.get_now_term()['name']
try:
for username in usernames:
user = dao.User.get_user(query_dict={'username': username})
school_term = SchoolTerm(term)
supervisor = dao.Supervisor.get_supervisor(query_dict={
'username': username,
'term': term
})
for i in range(0, 4):
school_term = school_term + 1
data['term'] = school_term.term_name
(_, num) = dao.Term.query_terms(
query_dict={'name': [school_term.term_name]})
if num == 0:
dao.Term.insert_term(
ctx=False, data={'name': school_term.term_name})
(_, num) = dao.Supervisor.query_supervisors(query_dict={
'username':
username,
'term': [data['term']]
},
unscoped=False)
if num != 0:
continue
data['username'] = username
data['group_name'] = supervisor['group_name']
data['name'] = user['name']
data['unit'] = user['unit']
dao.Supervisor.insert_supervisor(ctx=False, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_work_plan(cls, ctx: bool = True, id: int = 0):
work_plan = dao.WorkPlan.get_work_plan(query_dict={'id': id}, unscoped=False)
if work_plan is None:
raise CustomError(404, 404, 'work_plan not found')
try:
dao.WorkPlan.delete_work_plan(ctx=False, query_dict={'id': [id]})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def get_notice_lesson(cls, query_dict: dict, unscoped: bool = False):
notice_lesson_teacher = dao.NoticeLesson.get_notice_lesson(
query_dict=query_dict, unscoped=unscoped)
if notice_lesson_teacher is None:
raise CustomError(404, 404, 'notice_lesson_teacher not found')
return notice_lesson_teacher
def delete_user(cls, ctx: bool = True, username: str = ''):
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, '用户未找到')
try:
dao.User.delete_user(ctx=ctx, username=username)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def delete_event(cls, ctx: bool = True, id: int = 0):
event = dao.Event.get_event(query_dict={'id':id}, unscoped=False)
if event is None:
raise CustomError(404, 404, 'event not found')
try:
dao.Event.delete_event(ctx=False, query_dict={'id': [id]})
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
return True
def insert_user(cls,
ctx: bool = True,
data: dict = None,
default_password='******'):
if data is None:
data = dict()
data = cls.reformatter(data)
username = data.get('username', None)
if username is None:
raise CustomError(500, 200, 'username should be given')
try:
dao.User.get_user(query_dict={'username': username})
except CustomError as e:
if e is not None:
raise CustomError(500, 200, 'username has been used')
elif e is not None and e.status_code != 404:
raise e
try:
if data.get('password', None) is None:
data['password'] = default_password
role_names = data.get('role_names', [])
role_name_dict = {
'管理员': 'is_admin',
'学院领导': 'is_leader',
'校级管理员': 'is_reader'
}
for role_name in role_names:
role_name_filed = role_name_dict[role_name]
data[role_name_filed] = True
dao.User.insert_user(ctx=ctx, data=data)
if ctx:
db.session.commit()
except Exception as e:
if ctx:
db.session.rollback()
if isinstance(e, CustomError):
raise e
else:
raise CustomError(500, 500, str(e))
role_names = data.get('role_names', [])
if '督导' in role_names:
send_kafka_message(topic='user_service',
method='add_supervisor',
usernames=[username])
return True
def change_user_password(cls, username, password):
user = dao.User.get_user(query_dict={'username': username}, unscoped=False)
if user is None:
raise CustomError(404, 404, '用户未找到')
dao.User.update_user(ctx=False, username=username, data={
'password': password
})
return True
