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
