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):
"""
获取学生的简历路径
成功：返回{'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 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 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 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 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 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):
"""
删除简历（只删除学生信息的简历路径）
成功：返回{'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 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 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 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 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 update(works_id, stu_id, name, duty, url, description, img, audio, video):
"""
修改作品集信息
成功：返回{'tag': OK_UPDATE_WORKS}
失败：返回{'tag': ERR_UPDATE_WORKS_DB}
"""
select_rlt = stu_info.select(stu_id=stu_id)
# 如果学生存在
if select_rlt['tag'] == stu_info.OK_SELECT:
return {'tag': OK_UPDATE_WORKS} \
if works.update(
works_id, select_rlt['stu'], name, duty, url, description, img, audio, video
) == works.OK_UPDATE \
else {'tag': ERR_UPDATE_WORKS_DB}
# 如果学生不存在
elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST:
logger.warning('尝试更新不存在的学生的作品集信息')
return {'tag': ERR_UPDATE_WORKS_DB}
# 如果数据库异常导致无法确认学生是否存在(select_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致无法确认学生是否存在，修改作品集信息失败')
return {'tag': ERR_UPDATE_WORKS_DB}
def add(stu_id, name, value):
"""
增加技能评价
成功：返回{'tag': OK_ADD_SKILL, 'skill_id': insert_rlt['skill'].skill_id}
失败：返回{'tag': ERR_ADD_SKILL_DB}或{'tag': ERR_ADD_SKILL_FULL}
@stu_id:关联的学生id
@name: 技能名称
@value: 技能值
"""
select_rlt = stu_info.select(stu_id=stu_id)
# 如果学生存在
if select_rlt['tag'] == stu_info.OK_SELECT:
# 如果评价数量已满
if skill.stu_filter(select_rlt['stu']).count() >= 8:
logger.error('技能评价数量已满')
return {'tag': ERR_ADD_SKILL_FULL}
insert_rlt = \
skill.insert(name=name, value=value, stu=select_rlt['stu'])
# 如果插入成功：
if insert_rlt['tag'] == skill.OK_INSERT:
return {
'tag': OK_ADD_SKILL,
'skill_id': insert_rlt['skill'].skill_id
}
# 如果插入失败（insert_rlt['tag'] == ERR_INSERT_DB）
else:
return {'tag': ERR_ADD_SKILL_DB}
# 如果学生记录不存在
elif select_rlt['tag'] == stu_info.ERR_SELECT_NOTEXIST:
logger.warning('尝试为不存在的学生增加技能评价')
return {'tag': ERR_ADD_SKILL_DB}
# 如果数据库异常导致获取学生信息失败(select_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致无法确认学生是否存在，增加技能评价失败')
return {'tag': ERR_ADD_SKILL_DB}
def get(stu_id):
"""
获取学生信息
成功：返回{'tag': OK_GET_INFO, 'stu': select_rlt['stu']}
失败:返回{'tag': ERR_GET_INFO_NOTEXIST}
或{'tag': ERR_GET_INFO_DB}
"""
select_rlt = stu_info.select(stu_id=stu_id)
# 如果学生存在
if select_rlt['tag'] == OK_SELECT:
return {'tag': OK_GET_INFO, 'stu': select_rlt['stu']}
# 'engineering_isSet': select_rlt['engineering_isSet'],
# 'literature_isSet': select_rlt['literature_isSet'],
# 'management_isSet': select_rlt['management_isSet'],
# 'humanity_isSet': select_rlt['humanity_isSet']}
# 如果学生记录不存在
elif select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.error('学生不存在，获取学生信息失败')
return {'tag': ERR_GET_INFO_NOTEXIST}
# 如果数据库异常导致获取学生信息失败(select_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致获取学生信息失败')
return {'tag': ERR_GET_INFO_DB}
def upload(stu_id, resume):
"""
上传简历文件
@stu_id 学生id
@resume: 简历文件
成功：返回{'tag': OK_SAVE_RESUME, 'path': resume_path}
失败：返回{'tag': ERR_SAVE_RESUME_FAIL}
"""
def check_resume_file(file): # TODO(hjf): Check resume file
"""return true if avatar file is valid"""
return True
def get_resume_path(folder, file_name, file_type):
return '%s/%s/%s.%s' % (RESUME_PATH_ROOT, folder, file_name, file_type)
# 确认学生是否存在
select_rlt = stu_info.select(stu_id=stu_id)
# 如果学生存在
if select_rlt['tag'] == OK_SELECT:
# 如果简历文件合法
if check_resume_file(resume):
pre_ref_path = select_rlt['stu'].resume_path
resume_path = get_resume_path(folder=stu_id,
file_name=int(time.time()),
file_type=file_helper.get_file_type(
resume.name)) # 用时间作简历文件名称
# 引用的简历路径
# ref_path = '/media/' + resume_path
ref_path = resume_path
# 更新学生的当前简历路径
update_stu_tag = stu_info.update(stu_id=stu_id,
resume_path=ref_path)
# 如果更新学生的当前简历路径成功：
if update_stu_tag == OK_UPDATE:
# 如果简历文件上传成功
if file_helper.save(resume, resume_path):
return {'tag': OK_SAVE_RESUME, 'path': ref_path}
# 如果简历文件上传失败，
else:
logger.error('简历文件上传失败')
# 回滚
roll_tag = stu_info.update(stu_id=stu_id,
resume_path=pre_ref_path)
if roll_tag != OK_UPDATE:
logger.error('简历文件上传失败，但学生的简历路径已更新，无法回滚')
return {'tag': ERR_SAVE_RESUME_FAIL}
# 如果更新学生的当前简历路径时学生记录不存在
elif update_stu_tag == ERR_UPDATE_NOTEXIST:
logger.error('更新学生当前简历路径时，学生记录丢失，导致上传简历失败')
return {'tag': ERR_SAVE_RESUME_FAIL}
# 如果数据库异常导致无法更新学生的当前简历路径update_stu_tag == ERR_UPDATE_DB
else:
logger.error('数据库异常导致无法更新学生当前简历路径，上传简历失败')
return {'tag': ERR_SAVE_RESUME_FAIL}
# 如果简历不合法
else:
return {'tag': ERR_RESUME_FILE_INVALID}
# 如果学生不存在
elif select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试为不存在的学生上传简历')
return {'tag': ERR_SAVE_RESUME_FAIL}
# 如果数据库异常导致查询学生是否存在失败(select_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致无法确定学生是否存在，上传简历失败')
return {'tag': ERR_SAVE_RESUME_FAIL}
def apply(stu_id, job_id):
"""
投递简历
成功：返回{'tag': OK_APPLY, 'apply_id': insert_apply_rlt['apply'].id}
失败：返回{'tag': ERR_APPLY_DB}
或{’tag': ERR_APPLY_NO_RESUME}
@stu_id:学生id
@job_id:职位id
"""
select_stu_rlt = stu_info.select(stu_id)
# 如果学生存在
if select_stu_rlt['tag'] == OK_SELECT:
select_job_rlt = job.id_job(job_id)
# 如果职位存在
if select_job_rlt is not None:
team = select_job_rlt.team # team一定存在（由model外键的on_delete=CASCADE保证）
stu = select_stu_rlt['stu']
# 如果学生无简历
if stu.resume_path == NO_RESUME:
return {'tag': ERR_APPLY_NO_RESUME}
# 如果学生有简历
else:
select_apply_rlt = job_apply.stu_job_select(stu=stu,
job=select_job_rlt)
# 如果尚未投递
if select_apply_rlt['tag'] == ERR_SELECT_NOTEXIST:
insert_apply_rlt = \
job_apply.insert(stu=stu, job=select_job_rlt, state=0, team=team,
apply_time=date_helper.curr_time(), resume_path=stu.resume_path,
change_time=date_helper.now(), stu_read=True)
# 如果投递成功
if insert_apply_rlt['tag'] == OK_INSERT:
return {
'tag': OK_APPLY,
'apply_id': insert_apply_rlt['apply'].apply_id
}
# 如果投递失败insert_apply_rlt['tag'] == ERR_INSERT_DB
else:
logger.error('数据库异常导致投递记录插入失败，投递简历失败')
return {'tag': ERR_APPLY_DB}
# 如果已经投递过了
elif select_apply_rlt['tag'] == OK_SELECT:
return {'tag': ERR_APPLY_EXIST}
# 如果数据库异常导致无法确认是否已经投递过了(select_apply_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致无法确认是否已经投递过，投递简历失败')
return {'tag': ERR_APPLY_DB}
# 如果职位不存在(select_job_rlt is None)
else:
logger.warning('尝试投递简历给不存在的职位')
return {'tag': ERR_APPLY_DB}
# 如果学生不存在(select_stu_rlt['tag'] == ERR_SELECT_NOTEXIST)
elif select_stu_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试用不存在的学生投递简历')
return {'tag': ERR_APPLY_DB}
# 如果数据库异常导致无法确认学生是否存在(select_stu_rlt['tag'] == ERR_SELECT_DB)
else:
logger.error('数据库异常导致无法确认学生是否存在，投递简历失败')
return {'tag': ERR_APPLY_DB}
def team_get_info(apply_id):
"""
团队获取投递信息
成功：返回{'tag': OK_APPLY_INFO,
'stu_id': apply.stu_id,
'name': stu.name,
'avatar_path': stu.avatar_path,
'sex': stu.sex,
'age': stu.age,
'mail': stu.mail,
'tel': stu.tel,
'school': stu.school,
'major': stu.major,
'location': stu.location,
'resume_path': apply.resume_path,
'state': apply.state
}
失败：返回{'tag': ERR_APPLY_INFO_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:
stu = stu_select_rlt['stu']
account_select_rlt = account.stu_select(stu.id)
# 如果获取关联的账号成功
if account_select_rlt['tag'] == OK_SELECT:
return {'tag': OK_APPLY_INFO,
'stu_id': apply.stu_id,
'name': stu.name,
'avatar_path': stu.avatar_path,
'sex': stu.sex,
'age': '',
'mail': account_select_rlt['acnt'].account,
'tel': '',
'school': stu.school,
'major': '',
'location': '',
'resume_path': apply.resume_path,
'state': apply.state
}
# 如果获取关联的账号失败
else:
logger.error('数据库异常或学生不存在，无法获取与投递记录关联的学生信息(账号)')
return {'tag': ERR_APPLY_INFO_DB}
# 如果无法获取关联的学生
else:
logger.error('数据库异常，无法获取与投递记录关联的学生信息')
return {'tag': ERR_APPLY_INFO_DB}
# 如果投递记录不存在
elif apply_select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试获取不存在的投递记录的信息')
return {'tag': ERR_APPLY_INFO_DB}
# 如果数据库异常导致获取投递信息失败
else:
return {'tag': ERR_APPLY_INFO_DB}
def save(stu_id, avatar):
"""
保存头像
@stu_id:学生id
@avatar:头像文件
成功：返回{'tag': OK_SAVE_AVATAR, 'path': ref_path}
失败：返回{'tag': ERR_SAVE_AVATAR_FAIL}
或{'tag': ERR_AVATAR_FILE_INVALID}
"""
def check_avatar_file(file): # TODO(hjf): Check avatar file
"""return true if avatar file is valid"""
return True
def get_avatar_path(folder, file_name, file_type):
return '%s/%s/%s.%s' % (AVATAR_PATH_ROOT, folder, file_name, file_type)
# 确认学生是否存在
select_rlt = stu_info.select(stu_id=stu_id)
# 如果账号不存在
if select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试为不存在的学生上传头像')
return {'tag': ERR_SAVE_AVATAR_FAIL}
# 如果数据库异常导致查询学生是否存在失败
elif select_rlt['tag'] == ERR_SELECT_DB:
logger.error('数据库异常导致无法确定学生是否存在，上传头像失败')
return {'tag': ERR_SAVE_AVATAR_FAIL}
# 学生存在，如果头像合法
pre_ref_path = select_rlt['stu'].avatar_path
if check_avatar_file(avatar):
# 写入文件的路径
avatar_path = get_avatar_path(folder=stu_id,
file_name=int(time.time()),
file_type=file_helper.get_file_type(avatar.name)) # use time as avatar file name
# 引用头像的路径
# ref_path = '/media/' + avatar_path
ref_path = avatar_path
# 更新学生头像路径
update_tag = stu_info.update(stu_id=stu_id, avatar_path=ref_path)
# 如果更新头像路径成功
if update_tag == OK_UPDATE:
# 如果头像保存成功
if file_helper.save(avatar, avatar_path):
return {'tag': OK_SAVE_AVATAR,
'path': ref_path}
# 如果头像保存失败， 回滚
else:
roll_tag = stu_info.update(stu_id=stu_id, avatar_path=pre_ref_path)
# 如果回滚失败
if roll_tag != OK_UPDATE:
logger.error('头像保存失败，但数据库异常导致无法将已更新的头像路径恢复')
return {'tag': ERR_SAVE_AVATAR_FAIL}
# 如果写入路径失败
else:
return {'tag': ERR_SAVE_AVATAR_FAIL}
# 如果头像不合法
else:
return {'tag': ERR_AVATAR_FILE_INVALID}
