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 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):
"""
获取学生的作品集
"""
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 activate(account_cipher):
"""
激活账号
成功：返回OK_ACTIVATE
失败：返回ERR_ACTIVATE_NOTEXIST
或ERR_ACTIVATE_DB
@account_cipher: 加密后的account
"""
select_rlt = account.ciphertext_select(ciphertext=account_cipher)
if select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试激活不存在的账号')
return ERR_ACTIVATE_NOTEXIST
elif select_rlt['tag'] == ERR_SELECT_DB:
logger.error('数据库异常导致无法激活账号')
return ERR_ACTIVATE_DB
tag = account.update(account=select_rlt['acnt'].account, is_activated=True)
# 如果更新激活状态失败（账号不存在）
if tag == ERR_UPDATE_NOTEXIST:
logger.error('在激活账号过程中，账号记录丢失，激活失败')
return ERR_ACTIVATE_DB
# 如果更新激活状态失败（数据库异常）
elif tag == ERR_UPDATE_DB:
logger.error('数据库异常导致无法激活账号')
return ERR_ACTIVATE_DB
# 如果更新激活状态成功
return OK_ACTIVATE
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 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 handle(apply_id, new_state):
"""
处理投递（团队）
@apply_id:
@state: 投递状态，1表示待沟通，2表示待面试，3表示录用， 4表示不合适
成功：返回OK_HANDLE
失败：返回ERR_STATE或ERR_HANDLE_DB
"""
new_state = int(new_state)
if new_state not in range(1, 5):
logger.warning('尝试用不合法的state处理投递')
return ERR_STATE
apply_select_rlt = job_apply.id_select(apply_id)
# 如果查询投递记录成功
if apply_select_rlt['tag'] == OK_SELECT:
update_tag = job_apply.update(apply_id=apply_id, state=new_state, stu_read=False)
# 如果处理成功
if update_tag == OK_UPDATE:
return OK_HANDLE
# 如果处理失败(update_tag == ERR_UPDATE_DB)
else:
return ERR_HANDLE_DB
# 如果投递记录不存在
elif apply_select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试处理不存在的投递记录的信息')
return ERR_HANDLE_DB
# 如果数据库异常导致获取投递信息失败
else:
return ERR_HANDLE_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):
"""
获取学生的简历路径
成功：返回{'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 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 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 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 reset(account_cipher):
"""
重置账号，修改账号状态为未激活，修改密码为随机字符串的哈希值
@account_cipher: 由后端加密的account，只能通过邮件获得
成功：返回{'credential': credential, 'account': account}
失败：返回ERR_RESET_NOTEXIST
或ERR_SELECT_DB
"""
obj = account.ciphertext_select(ciphertext=account_cipher)
# 如果账号不存在
if obj['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试重置不存在的账号')
return ERR_RESET_NOTEXIST
# 如果数据库异常无法查询
elif obj['tag'] == ERR_SELECT_DB:
logger.error('数据库异常导致无法验证账号是否存在，无法重置账号')
return ERR_RESET_DB
# 如果账号存在，但重置账号的请求已过期
elif date_helper.pass_days(
obj['acnt'].reset_date) > date_helper.OUT_DATE_DAYS:
return ERR_RESET_OUT_DATE
# 如果账号存在，请求未过期，重置状态和密码
credential = get_hashcode()
tag = account.update(account=obj['acnt'].account,
is_activated=False,
pwd=credential)
# 如果更新账号时，账号不存在
if tag == ERR_UPDATE_NOTEXIST:
logger.error('重置账号时，账号记录丢失')
return ERR_RESET_NOTEXIST
# 如果数据库异常导致无法重置账号
elif tag == ERR_UPDATE_DB:
logger.error('数据库异常导致无法重置账号账号')
# 如果重置账号成功
return {
'credential': credential,
'account': obj['acnt'].account
} # 防止credential(哈希值）和ERROR_RESET_DOESNOTEXIST冲突
def set_read(apply_list):
"""
设置投递记录为已读(学生)
成功：返回{'tag': OK_READ_APPLY}
失败：返回{'tag': ERR_READ_APPLY_DB}
"""
fail_tag = False
for apply_id in apply_list:
update_tag = job_apply.update(apply_id=apply_id, stu_read=True)
# 如果更新失败(update_tag == ERR_UPDATE_DB)
if update_tag == ERR_UPDATE_DB:
logger.warning('apply_id为%s的投递记录设置已读失败' % apply_id)
fail_tag = True
# 如果更新成功
if not fail_tag:
return {'tag': OK_READ_APPLY}
# 如果更新失败(fail_tag)
else:
return {'tag': ERR_READ_APPLY_DB}
def id_stu_delete(skill_id, stu):
"""
用skill_id和stu删除技能评价
成功：返回OK_DELETE
失败：返回ERR_DELETE_DB
"""
try:
delete_skill = StuSkill.objects.all().get(skill_id=skill_id, stu=stu, is_deleted=False)
delete_skill.is_deleted = True
delete_skill.save()
return OK_DELETE
except StuSkill.DoesNotExist:
logger.warning("尝试删除学生id和技能评价id不匹配或已删除的技能评价")
return ERR_DELETE_DB
except Exception as e:
logger.error(e.__str__() + '数据库异常导致删除技能评价失败')
return ERR_DELETE_DB
def send_reset_mail(acnt):
"""
发送密码重置邮件，记录链接发送的时间
成功：发送重置邮件并返回OK_RESTE_MAIL
失败：返回ERR_RESET_MAIL_NOTEXIST
或ERR_RESET_MAIL_DB
@account: 账号（邮箱）
"""
select_rlt = account.acnt_select(account=acnt)
# 如果账号不存在
if select_rlt['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试发送重置邮件到不存在的账号')
return ERR_RESET_MAIL_NOTEXIST
# 如果数据异常无法查询
elif select_rlt['tag'] == ERR_SELECT_DB:
logger.error('数据库异常导致无法发送重置邮件')
return ERR_RESET_MAIL_DB
# 账号密文
ciphertext = encrypt(acnt)
# 如果账号存在，记录邮件发送的日期和账号密文，并发送邮件
update_tag = account.update(account=acnt,
reset_date=date_helper.now(),
ciphertext=ciphertext)
# 如果记录日期时，账号记录丢失
if update_tag == ERR_UPDATE_NOTEXIST:
logger.error('记录重置邮件发送日期时，账号记录丢失')
return ERR_RESET_MAIL_NOTEXIST
# 如果数据库异常无法记录邮件发送日期
elif update_tag == ERR_UPDATE_DB:
logger.error('数据库异常导致无法发送重置邮件')
return ERR_RESET_MAIL_DB
# 如果日期记录成功，发送邮件
send_163_mail('13660106752', 'xuegongban118', '*****@*****.**', acnt,
'WeMeet重置密码邮件', reset_mail.get_content(ciphertext, acnt))
return OK_RESET_MAIL
def change_pwd(acnt, credential, pwd):
"""
验证凭据激活账号修改密码
成功：激活账号，修改密码， 返回OK_CHANGE_PWD
失败：返回ERR_CHANGE_PWD_NOTEXIST
或ERR_CHANGE_PWD_WRONG_CREDENTIAL
或ERR_CHANGE_PWD_DB
"""
obj = account.acnt_select(account=acnt)
# 如果账号不存在
if obj['tag'] == ERR_SELECT_NOTEXIST:
logger.warning('尝试修改不存在账号的密码')
return ERR_CHANGE_PWD_NOTEXIST
# 如果数据异常导致无法验证账号是否存在
elif obj['tag'] == ERR_SELECT_DB:
logger.error('数据库异常导致无法修改密码（无法验证账号是否存在）')
return ERR_CHANGE_PWD_DB
# 账号存在，如果凭据错误
elif obj['acnt'].pwd != credential:
logger.info('以错误的凭据修改密码')
return ERR_CHANGE_PWD_WRONG_CREDENTIAL
# 如果账号存在，凭据正确，激活账号，并修改密码
else:
tag = account.update(account=acnt, is_activated=True, pwd=pwd)
# 如果数据库异常导致无法修改密码
if tag == ERR_UPDATE_DB:
logger.error('数据库异常导致无法修改密码')
return ERR_CHANGE_PWD_DB
# 如果修改密码时，账号不存在
elif tag == ERR_UPDATE_NOTEXIST:
logger.error('修改密码时，账号记录丢失')
return ERR_CHANGE_PWD_NOTEXIST
# 如果更新成功(tag == GOOD_UPDATE)
else:
return OK_CHANGE_PWD
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 update(apply_id, state=NO_INPUT, change_time=NO_INPUT, stu_read=NO_INPUT):
"""
用apply_id更新技能评价
成功：返回OK_UPDATE
失败：返回ERR_UPDATE_DB
"""
try:
update_apply = JobApply.objects.all().get(apply_id=apply_id)
update_apply.state = value_update.value(update_apply.state, state)
update_apply.change_time = value_update.value(update_apply.change_time,
change_time)
update_apply.stu_read = value_update.value(update_apply.stu_read,
stu_read)
update_apply.save()
return OK_UPDATE
except JobApply.DoesNotExist as e:
logger.warning(e.__str__() + "尝试更新不存在的投递记录")
return ERR_UPDATE_DB
except Exception as e:
logger.error(e.__str__() + ':数据库异常导致更新投递记录失败')
return ERR_UPDATE_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 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}
def team_get_list(team_id, state):
"""
团队获取投递列表
@team_id: 团队id
@state: 投递状态，0表示新接收，1表示待沟通，2表示待面试，3表示完成
成功：返回{
'tag': OK_GET_APPLY,
'unread_num': unread_num,
'apply_list': apply_list
}
失败：返回{'tag': ERR_GET_NO_APPLY}或{'tag': ERR_GET_APPLY_DB}
"""
state = int(state)
select_team = team.id_team(team_id)
if select_team is not None:
apply_list = []
unread_num = [0]
# （输入值）3表示完成，包括录用(返回值3)和不合适（返回值4）
if state == 3:
fail_tag = False
for state in range(3, 5):
dump_tag = dump_team_apply(select_team, state, apply_list, unread_num)
if dump_tag == ERR_DUMP_DB:
fail_tag = True
# 如果获取所需信息成功
if not fail_tag:
# 如果投递列表为空
if not apply_list:
return {'tag': ERR_GET_NO_APPLY}
# 如果投递列表不为空
return {
'tag': OK_GET_APPLY,
'unread_num': unread_num[0],
'apply_list': apply_list
}
# 如果数据库异常导致获取所需的信息失败
else:
return {'tag': ERR_GET_APPLY_DB}
elif state in range(0, 3):
dump_tag = dump_team_apply(select_team, state, apply_list, unread_num)
# 如果获取所需信息成功
if dump_tag == OK_DUMP:
# 如果投递列表为空
if not apply_list:
return {'tag': ERR_GET_NO_APPLY}
# 如果投递列表不为空
return {
'tag': OK_GET_APPLY,
'unread_num': unread_num[0],
'apply_list': apply_list
}
# 如果数据库异常导致获取所需的信息失败
else:
return {'tag': ERR_GET_APPLY_DB}
# 如果state不合法
else:
logger.warning('尝试用不合法的状态查询投递记录')
return {'tag': ERR_GET_APPLY_DB}
# 如果团队不存在
else:
logger.warning('尝试获取不存在团队的投递信息')
return {'tag': ERR_GET_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}
