def delete(stu_id): """ 删除 成功返回OK_DELETE 失败返回ERR_DELETE_DB """ try: delete_stu = StuInfo.objects.all().get( id=stu_id) # 抛出MultipleObjectsReturned或DoesNotExist delete_stu.delete() # 不抛出异常 return OK_DELETE except StuInfo.DoesNotExist: logger.error('尝试删除不存在的学生') return ERR_DELETE_DB except StuInfo.MultipleObjectsReturned: logger.info('数据库异常(存在重复记录)') StuInfo.objects.all().filter(id=stu_id).delete() # 不抛异常 return OK_DELETE # 数据库异常 except Exception as e: logger.error(e.__str__() + '数据库异常导致删除学生失败') return ERR_DELETE_DB
def insert(name, title, personal_signature, sex, school, grade, avatar_path, is_engineering, is_literature, is_management, is_humanity): """ 成功:返回插入的学生 失败:返回ERROR_INSERT """ try: new_stu = StuInfo(name=name, title=title, personal_signature=personal_signature, sex=sex, school=school, grade=grade, avatar_path=avatar_path, is_engineering=is_engineering, is_literature=is_literature, is_management=is_management, is_humanity=is_humanity, likes=0, resume_path=NO_RESUME) new_stu.save() # 如果是手工设置的主键,会抛出 IntegrityError return new_stu # return GOOD_INSERT except Exception as e: logger.error(e.__str__() + '数据库异常导致插入学生失败') return ERR_INSERT_DB
def login(acnt, pwd): """ 登陆 成功:返回OK_LOGIN和学生id 失败:返回ERR_LOGIN_NOTEXIST 或ERR_LOGIN_DB 或ERR_LOGIN_WRONG_PWD 或ERR_LOGIN_NONACTIVATED @account: 账号(邮箱) @pwd: 密码 """ rlt = account.acnt_select(account=acnt) # 如果账号不存在 if rlt['tag'] == ERR_SELECT_NOTEXIST: return {'tag': ERR_LOGIN_NOTEXIST} # 如果数据库异常 elif rlt['tag'] == ERR_SELECT_DB: logger.error('数据库异常导致登陆失败') return {'tag': ERR_LOGIN_DB} # 如果账号未激活 elif not rlt['acnt'].is_activated: return {'tag': ERR_LOGIN_NONACTIVATED} # 如果密码错误 elif rlt['acnt'].pwd != pwd: return {'tag': ERR_LOGIN_WRONG_PWD} # 登陆成功 else: token = gen_token(rlt['acnt'].stu.id, 0) return {'tag': OK_LOGIN, 'stu_id': rlt['acnt'].stu.id, 'token': token}
def update(stu_id, name, title, personal_signature, sex, school, grade, avatar_path, is_engineering, is_literature, is_management, is_humanity): """ 更新学生信息 成功:返回OK_UPDATE_INFO 失败:返回ERR_UPDATE_DB """ stu_update_tag = stu_info.update(stu_id=stu_id, name=name, title=title, personal_signature=personal_signature, sex=int(sex), school=school, grade=int(grade), avatar_path=avatar_path, is_engineering=is_engineering, is_literature=is_literature, is_management=is_management, is_humanity=is_humanity) # 如果学生信息更新成功 if stu_update_tag == OK_UPDATE: return OK_UPDATE_STU_INFO elif stu_update_tag == ERR_UPDATE_NOTEXIST: logger.error('学生不存在,无法更新学生信息') return ERR_UPDATE_STU_INFO_DB # 如果stu_update_tag == ERR_UPDATE_DB else: logger.error('数据库异常导致更新学生信息失败') return ERR_UPDATE_DB
def add(stu_id, name, duty, url, description, img, audio, video): """ 增加作品集信息 成功:返回{'tag': OK_ADD_WORKS, 'works_id': insert_rlt['works'].works_id} 失败:返回{'tag': ERR_ADD_WORKS_DB}或{'tag': ERR_ADD_WORKS_FULL} """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: filter_set = works.stu_filter(stu=select_rlt['stu']) # 如果该学生有合法的作品数量数量 if filter_set.count() < 6: insert_rlt = works.insert(name, duty, url, description, select_rlt['stu'], img, audio, video) if insert_rlt['tag'] == works.OK_INSERT: return {'tag': OK_ADD_WORKS, 'works_id': insert_rlt['works'].works_id} else: return {'tag': ERR_ADD_WORKS_FULL} # 如果学生记录不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试为不存在的学生增加作品集信息') return {'tag': ERR_ADD_WORKS_DB} # 如果数据库异常导致获取学生信息失败(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,增加作品集信息失败') return {'tag': ERR_ADD_WORKS_DB}
def reply(apply_id, text): """ 邮件回复投递(团队) @apply_id: @text: 邮件内容 成功:返回OK_REPLY 失败:返回ERR_REPLY_DB """ apply_select_rlt = job_apply.id_select(apply_id) # 如果查询投递记录成功 if apply_select_rlt['tag'] == OK_SELECT: apply = apply_select_rlt['apply'] stu_select_rlt = stu_info.select(apply.stu_id) # 如果获取关联的学生成功 if stu_select_rlt['tag'] == OK_SELECT: mail = stu_select_rlt['stu'].mail send_mail('WeMeet投递职位回复邮件', text, '*****@*****.**', [mail]) # TODO(hjf): 修改邮件标题、发送邮箱 return OK_REPLY # 如果无法获取关联的学生 else: logger.error('数据库异常,无法获取与投递记录关联的学生信息') return ERR_REPLY_DB # 如果投递记录不存在 elif apply_select_rlt['tag'] == ERR_SELECT_NOTEXIST: logger.warning('尝试回复不存在的投递') return ERR_REPLY_DB # 如果数据库异常导致获取投递信息失败 else: return ERR_REPLY_DB
def delete(stu_id, works_id): """ 删除作品 成功:返回{'tag': OK_DEL_WORKS} 失败:返回{'tag': ERR_DEL_WORKS_DB} """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: delete_tag = works.delete(works_id, select_rlt['stu']) if delete_tag == works.OK_DELETE: return {'tag': OK_DEL_works} # delete_tag == ERR_DELETE_DB else: return {'tag': ERR_DEL_works_DB} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试删除不存在的学生的技能评价') return {'tag': ERR_DEL_works_DB} # 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,删除技能评价失败') return {'tag': ERR_DEL_works_DB}
def get(stu_id): """ 获取技能评价 成功:{'tag': OK_GET_SKILL, 'skill_list': list(filter_set.values())} "skill_list": [{ "skill_id": skill_id, "name": name, "value": value}, ...]} 失败:{'tag': ERR_GET_NO_SKILL}或{'tag': ERR_GET_SKILL_DB} """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: filter_set = skill.stu_filter(stu=select_rlt['stu']) # 如果该学生有合法的技能评价数量 if filter_set.count() != 0: return { 'tag': OK_GET_SKILL, 'skill_list': list(filter_set.values()) } # 如果该学生无技能评价 filter_set.count() == 0 else: return {'tag': ERR_GET_NO_SKILL} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试获取不存在的学生的技能评价') return {'tag': ERR_GET_SKILL_DB} # 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,查询技能评价失败') return {'tag': ERR_GET_SKILL_DB}
def update(works_id, stu, name=NO_INPUT, duty=NO_INPUT, url=NO_INPUT, description=NO_INPUT, img=NO_INPUT, audio=NO_INPUT, video=NO_INPUT): """ 成功:返回OK_UPDATE 失败:返回ERR_UPDATE_NOTEXIST 或ERR_UPDATE_DB """ try: update_works = StuWorks.objects.all().get(works_id=works_id, stu=stu, is_deleted=False) update_works.name = value(update_works.name, name) update_works.duty = value(update_works.duty, duty) update_works.url = value(update_works.url, url) update_works.description = value(update_works.description, description) update_works.img = value(update_works.img, img) update_works.audio = value(update_works.audio, audio) update_works.video = value(update_works.video, video) update_works.save() return OK_UPDATE except StuWorks.DoesNotExist: logger.error('尝试更新学生id和作品信息id不匹配或已删除的作品集信息') return ERR_UPDATE_NOTEXIST except Exception as e: logger.error(e.__str__() + '数据库异常导致更新作品信息失败') return ERR_UPDATE_DB
def dump_team_apply(team, state, rlt_list, unread_num): """ 从JobApply的QuerySet里获取团队查询投递关系所需要的信息 """ apply_set = job_apply.team_state_filter(team=team, state=state) for apply in apply_set: apply_job = job.id_job(apply.job_id) select_rlt = stu_info.select(apply.stu_id) # 如果数据库异常导致无法查询投递关联的学生 if select_rlt['tag'] != OK_SELECT: logger.error('数据库异常导致无法查询apply_id为%s的投递关联的学生' % (apply.apply_id)) return ERR_DUMP_DB is_read = True if state == 0: is_read = False # 如果获取学生成功 apply_stu = select_rlt['stu'] rlt_list.append({'apply_id': apply.apply_id, 'state': state, 'job_id': apply.job_id, 'stu_id': apply.stu_id, 'job_name': apply_job.name, 'stu_name': apply_stu.name, 'apply_time': apply.apply_time, 'is_read': int(is_read) }) if not is_read: unread_num[0] += 1 return OK_DUMP
def get(stu_id): """ 获取学生的简历路径 成功:返回{'tag': OK_GET_RESUME, 'resume_path': select_rlt['stu'].resume_path} 失败:返回{'tag': ERR_GET_RESUME_DB} """ select_rlt = stu_info.select(stu_id) # 如果学生存在 if select_rlt['tag'] == OK_SELECT: # 如果没有简历 if select_rlt['stu'].resume_path == NO_RESUME: return {'tag': ERR_GET_NO_RESUME} # 如果成功 return { 'tag': OK_GET_RESUME, 'resume_path': select_rlt['stu'].resume_path } # 如果学生不存在 elif select_rlt['tag'] == ERR_SELECT_NOTEXIST: logger.warning('尝试获取不存在学生的简历路径') return {'tag': ERR_GET_RESUME_DB} # 如果数据库异常导致无法确认学生是否存在 select_rlt['tag'] == ERR_SELECT_DB else: logger.error('数据库异常导致无法确认学生是否存在,获取简历路径失败') return {'tag': ERR_GET_RESUME_DB}
def delete(stu_id): """ 删除简历(只删除学生信息的简历路径) 成功:返回{'tag': OK_DEL_RESUME} 失败:返回{'tag': ERR_DEL_RESUME_DB} """ select_rlt = stu_info.select(stu_id) # 如果学生存在 if select_rlt['tag'] == OK_SELECT: stu = select_rlt['stu'] update_rlt = stu_info.update(stu_id=stu.id, resume_path=NO_RESUME) if update_rlt == OK_UPDATE: return {'tag': OK_DEL_RESUME} else: logger.error('数据库异常导致无法删除学生的简历(路径)') return {'tag': ERR_DEL_RESUME_DB} # 如果学生不存在 elif select_rlt['tag'] == ERR_SELECT_NOTEXIST: logger.warning('尝试删除不存在学生的简历路径') return {'tag': ERR_DEL_RESUME_DB} # 如果数据库异常导致无法确认学生是否存在 select_rlt['tag'] == ERR_SELECT_DB else: logger.error('数据库异常导致无法确认学生是否存在,删除简历路径失败') return {'tag': ERR_DEL_RESUME_DB}
def id_stu_update(skill_id, stu, name=NO_INPUT, value=NO_INPUT): """ 用skill_id和stu更新技能评价 成功:返回OK_UPDATE 失败:返回ERR_UPDATE_DB @skill_id: 技能评价id @stu: 关联的学生 @name: 技能名称 @value: 评价值 """ try: update_skill = StuSkill.objects.all().get(skill_id=skill_id, stu=stu, is_deleted=False) update_skill.name = value_update.value(update_skill.name, name) update_skill.value = value_update.value(update_skill.value, value) update_skill.save() return OK_UPDATE except StuSkill.DoesNotExist: logger.warning("尝试更新学生id和技能评价id不匹配或已删除的技能评价") return ERR_UPDATE_DB except Exception as e: logger.error(e.__str__() + '数据库异常导致更新技能评价失败') return ERR_UPDATE_DB
def delete(stu_id, skill_id): """ 删除技能评价 成功:返回{'tag': OK_DEL_SKILL} 失败:返回{'tag': ERR_DEL_SKILL_DB} """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: delete_tag = skill.id_stu_delete(skill_id, select_rlt['stu']) if delete_tag == skill.OK_DELETE: return {'tag': OK_DEL_SKILL} # delete_tag == ERR_DELETE_DB else: return {'tag': ERR_DEL_SKILL_DB} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试删除不存在的学生的技能评价') return {'tag': ERR_DEL_SKILL_DB} # 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,删除技能评价失败') return {'tag': ERR_DEL_SKILL_DB}
def get(stu_id): """ 获取学生的作品集 """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: filter_set = works.stu_filter(stu=select_rlt['stu']) # 如果该学生有合法的作品数量数量 if filter_set.count() in range(1, 6): return {'tag': OK_GET_WORKS, 'works_list': list(filter_set.values())} # 如果该学生无作品 elif filter_set.count() == 0: return {'tag': ERR_GET_NO_WORKS} # 如果该学生的作品数量不合法 else: logger.error('学生id为%s的学生拥有不合法的作品数量,导致获取作品失败' % stu_id) return {'tag': ERR_GET_WORKS_DB} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试获取不存在的学生的作品') return {'tag': ERR_GET_WORKS_DB} # 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,查询作品失败') return {'tag': ERR_GET_WORKS_DB}
def update(skill_id, stu_id, name, value): """ 修改技能评价 成功:返回{'tag': OK_UPDATE_SKILL} 失败:返回{'tag': ERR_UPDATE_SKILL_DB} @skill_id: 技能评价的id @stu_id: 关联的学生id @name: 技能名称 @value: 技能值 """ select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: update_tag = \ skill.id_stu_update(skill_id, select_rlt['stu'], name, value) # 如果更新成功 if update_tag == skill.OK_UPDATE: return {'tag': OK_UPDATE_SKILL} # 如果更新失败 else: return {'tag': ERR_UPDATE_SKILL_DB} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试更新不存在的学生的技能评价') return {'tag': ERR_UPDATE_SKILL_DB} # 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确认学生是否存在,修改技能评价失败') return {'tag': ERR_UPDATE_SKILL_DB}
def get(stu_id): rlt = about_me.stu_filter(stu_id) if rlt['tag'] == about_me.OK_SELECT: return {'tag': OK_GET_ABOUT_ME, 'about_me_list': list(rlt['about_me'].values())} # 如果异常导致获取学生"关于我"失败 else: logger.error('数据库异常导致获取学生信息失败') return {'tag': ERR_GET_ABOUT_ME_DB}
def delete(path): if default_storage.exists(path) and path != '': try: default_storage.delete(path) # 如果目标文件系统不支持删除文件操作 except NotImplementedError as err: logger.error('目标文件系统不支持删除文件操作') return False return True
def update(stu_id, name=NO_INPUT, title=NO_INPUT, personal_signature=NO_INPUT, sex=NO_INPUT, school=NO_INPUT, grade=NO_INPUT, avatar_path=NO_INPUT, resume_path=NO_INPUT, is_engineering=NO_INPUT, is_literature=NO_INPUT, is_management=NO_INPUT, is_humanity=NO_INPUT, likes=NO_INPUT): """ 成功:返回OK_UPDATE 失败:返回ERR_UPDATE_NOTEXIST 或ERR_UPDATE_DB """ try: update_stu = StuInfo.objects.all().get(id=stu_id) # 工程文艺经管人文(0000) # label = update_stu.label # humanity_isSet = value(label % 2, humanity_isSet) # management_isSet = value(label % 4 // 2, management_isSet) # literature_isSet = value(label % 8 // 4, literature_isSet) # engineering_isSet = value(label % 16 // 8, engineering_isSet) update_stu.name = value(update_stu.name, name) update_stu.sex = value(update_stu.sex, sex) update_stu.title = value(update_stu.title, title) update_stu.personal_signature = value(update_stu.personal_signature, personal_signature) update_stu.grade = value(update_stu.grade, grade) update_stu.school = value(update_stu.school, school) # update_stu.label = int(humanity_isSet + management_isSet * 2 + literature_isSet * 4 + engineering_isSet * 8) update_stu.is_engineering = value(update_stu.is_engineering, is_engineering) update_stu.is_literature = value(update_stu.is_literature, is_literature) update_stu.is_management = value(update_stu.is_management, is_management) update_stu.is_humanity = value(update_stu.is_humanity, is_humanity) update_stu.likes = value(update_stu.likes, likes) update_stu.avatar_path = value(update_stu.avatar_path, avatar_path) update_stu.resume_path = value(update_stu.resume_path, resume_path) update_stu.save() return OK_UPDATE except StuInfo.DoesNotExist: logger.error('尝试更新不存在的学生') return ERR_UPDATE_NOTEXIST except Exception as e: logger.error(e.__str__() + '数据库异常导致更新学生失败') return ERR_UPDATE_DB
def save(file, path): if default_storage.exists(path): try: default_storage.delete(path) # 如果目标文件系统不支持删除文件操作 except NotImplementedError as err: logger.error('目标文件系统不支持删除文件操作') return False default_storage.save(path, ContentFile(file.read())) return True
def stu_update(stu_id, account): try: update_account = StuAccount.objects.all().get(stu_id=stu_id) update_account.account = account update_account.save() return OK_UPDATE except StuAccount.DoesNotExist: return ERR_UPDATE_NOTEXIST except Exception as e: logger.error(e.__str__() + '数据库异常导致账号更新失败') return ERR_UPDATE_DB
def stu_get_list(stu_id, state): """ 学生获取投递列表 @stu_id: 学生id @state: 投递状态,0表示待查看,1表示待沟通,2表示待面试,3表示录用, 4表示不合适,5表示全部 成功:返回{ 'tag': OK_GET_APPLY, 'apply_list': apply_list } 失败:返回{'tag': ERR_GET_NO_APPLY}或{'tag': ERR_GET_APPLY_DB} """ state = int(state) select_rlt = stu_info.select(stu_id) # 如果学生存在 if select_rlt['tag'] == OK_SELECT: apply_list = [] if state == 5: for s in range(0, 5): dump_stu_apply(stu=select_rlt['stu'], state=s, rlt_list=apply_list) if not apply_list: return {'tag': ERR_GET_NO_APPLY} return { 'tag': OK_GET_APPLY, 'apply_list': apply_list } elif state in range(0, 5): dump_stu_apply(stu=select_rlt['stu'], state=state, rlt_list=apply_list) if not apply_list: return {'tag': ERR_GET_NO_APPLY} return { 'tag': OK_GET_APPLY, 'apply_list': apply_list } else: logger.warning('尝试用不合法的状态查询投递记录') return {'tag': ERR_GET_APPLY_DB} # 如果学生不存在 elif select_rlt['tag'] == ERR_SELECT_NOTEXIST: logger.warning('尝试获取不存在学生的投递信息') return {'tag': ERR_GET_APPLY_DB} # 如果数据库异常导致无法确认学生是否存在 else: logger.error('数据库异常导致无法确认学生是否存在,获取学生的投递信息失败') return {'tag': ERR_GET_APPLY_DB}
def id_select(apply_id): """ 成功:返回{'tag': OK_SELECT, 'apply': select_apply} 失败:返回{'tag': ERR_SELECT_NOTEXIST} 或{'tag': ERR_SELECT_DB} """ try: select_apply = JobApply.objects.all().get(apply_id=apply_id) return {'tag': OK_SELECT, 'apply': select_apply} except JobApply.DoesNotExist: return {'tag': ERR_SELECT_NOTEXIST} except Exception as e: logger.error(e.__str__() + '数据库异常导致查询投递记录失败') return {'tag': ERR_SELECT_DB}
def stu_job_select(stu, job): """ 用学生id和职位id查询投递记录 成功: 返回{'tag': OK_SELECT, 'apply': select_apply} 失败: 返回{'tag': ERR_SELECT_NOTEXIST} 或{'tag': ERR_SELECT_DB} """ try: select_apply = JobApply.objects.get(stu=stu, job=job) return {'tag': OK_SELECT, 'apply': select_apply} except JobApply.DoesNotExist: return {'tag': ERR_SELECT_NOTEXIST} except Exception as e: logger.error(e.__str__() + '数据库异常导致查询投递记录失败') return {'tag': ERR_SELECT_DB}
def select(stu_id): """ 成功:返回{'tag': OK_SELECT, 'stu': select_stu} 失败:返回{'tag': ERR_SELECT_NOTEXIST} 或{'tag': ERR_SELECT_DB} """ try: select_stu = StuInfo.objects.all().get(id=stu_id) return {'tag': OK_SELECT, 'stu': select_stu} except StuInfo.DoesNotExist: return {'tag': ERR_SELECT_NOTEXIST} except Exception as e: logger.error(e.__str__() + '数据库异常导致查询学生失败') return {'tag': ERR_SELECT_DB}
def ciphertext_select(ciphertext): """ 用密文查找账号 成功:返回{'tag': OK_SELECT, 'acnt': select_acnt} 失败:返回{'tag': ERR_SELECT_NOTEXIST} 或{'tag': ERR_SELECT_DB} """ try: select_acnt = StuAccount.objects.all().get(ciphertext=ciphertext) return {'tag': OK_SELECT, 'acnt': select_acnt} except StuAccount.DoesNotExist: return {'tag': ERR_SELECT_NOTEXIST} except Exception as e: logger.error(e.__str__() + '数据库异常导致账号查询失败') return {'tag': ERR_SELECT_DB}
def upload(stu_id, works_file): """ 上传作品集文件 @stu_id 学生id @works: 作品集文件 成功:返回{'tag': OK_SAVE_WORKS, 'path': ref_path} 失败:返回{'tag': ERR_SAVE_WORKS_FAIL} """ def check_resume_file(file): # TODO(hjf): Check works file """return true if works file is valid""" return True def get_works_path(folder, file_name, file_type): return '%s/%s/%s.%s' % (WORKS_PATH_ROOT, folder, file_name, file_type) # 确认学生是否存在 select_rlt = stu_info.select(stu_id=stu_id) # 如果学生存在 if select_rlt['tag'] == stu_info.OK_SELECT: # 如果作品集文件合法 if check_resume_file(works_file): works_path = get_works_path(folder=stu_id, file_name=int(time.time()), file_type=file_helper.get_file_type(works_file.name)) # 用time作简历文件名称 # ref_path = '/media/' + works_path ref_path = works_path # 如果作品集文件上传成功 if file_helper.save(works_file, works_path): return {'tag': OK_SAVE_WORKS, 'path': ref_path} # 如果作品集文件上传失败, else: return {'tag': ERR_SAVE_WORKS_FAIL} # 如果作品集文件不合法 else: return {'tag': ERR_WORKS_FILE_INVALID} # 如果学生不存在 elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST: logger.warning('尝试为不存在的学生上传作品集') return {'tag': ERR_SAVE_WORKS_FAIL} # 如果数据库异常导致查询学生是否存在失败(select_rlt['tag'] == ERR_SELECT_DB) else: logger.error('数据库异常导致无法确定学生是否存在,上传作品集失败') return {'tag': ERR_SAVE_WORKS_FAIL}
def insert(name, value, stu): """ 插入技能评价 成功:返回{'tag': OK_INSERT, 'skill': new_skill} 失败:返回{'tag': ERR_INSERT_DB} """ try: new_skill = StuSkill(name=name, value=value, stu=stu, is_deleted=False) new_skill.save() return {'tag': OK_INSERT, 'skill': new_skill} except Exception as e: logger.error(e.__str__() + '数据库异常导致插入技能评价记录失败') return {'tag': ERR_INSERT_DB}
def insert(account, pwd, stu): """ 成功:返回插入的账号 失败:返回ERR_INSERT """ try: new_account = StuAccount(account=account, pwd=pwd, is_activated=False, ciphertext=DEFAULT_CIPHERTEXT, reset_date=pre_date(), stu=stu) new_account.save() return new_account # 如果插入账号发生异常 except Exception as e: logger.error(e.__str__() + '数据库异常导致插入账号失败') return ERR_INSERT_DB
def delete(account): try: delete_acnt = StuInfo.objects.all().get( account=account) # 抛出MultipleObjectsReturned或DoesNotExist delete_acnt.delete() # 不抛出异常 return OK_DELETE except StuAccount.DoesNotExist: logger.error('尝试删除不存在的账号') return ERR_DELETE_DB except StuInfo.MultipleObjectsReturned: logger.info('数据库异常(存在重复记录)') StuInfo.objects.all().filter(account=account).delete() # 不抛异常 return OK_DELETE # 数据库异常 except Exception as e: logger.error(e.__str__() + '数据库异常导致删除账号失败') return ERR_DELETE_DB