2318 lines
92 KiB
Python
2318 lines
92 KiB
Python
import ast
|
||
import itertools
|
||
import json
|
||
import operator
|
||
import os
|
||
import re
|
||
from typing import Any
|
||
from obs import ObsClient
|
||
from copy import deepcopy
|
||
import pandas as pd
|
||
import pymongo
|
||
from fastapi import APIRouter, Depends, Request, File, UploadFile
|
||
from fastapi.security import OAuth2PasswordRequestForm
|
||
from motor.motor_asyncio import AsyncIOMotorDatabase
|
||
|
||
from api import deps
|
||
# from utils.dingding import get_redis_alluid, send_dates,unionid,get_alluid_list
|
||
from core import security
|
||
from core.config import settings
|
||
from core.security import get_password_hash
|
||
from schemas import ExtendendOAuth
|
||
from utils.dingding import *
|
||
from utils.jianli import get_resume
|
||
from utils.re_to_jianli import fmt_txt, getText_pdf
|
||
from utils.func import get_uid
|
||
import crud, schemas
|
||
from datetime import datetime
|
||
from core.configuration import *
|
||
from db import get_database
|
||
from db.ckdb import get_ck_db, CKDrive
|
||
from datetime import timedelta
|
||
from models.interview_zsgc import InterviewDo
|
||
from utils import get_time, qujian_time, Download_xlsx, send_str_mail, doc2pdf
|
||
|
||
router = APIRouter()
|
||
|
||
# 创建ObsClient实例
|
||
obsClient = ObsClient(
|
||
access_key_id='UPEO770G619UPU8TU61Y',
|
||
secret_access_key='M7zVRT1pjRtGSZ2TOZwKBRoVJLeWAOf633kHaNcu',
|
||
server='obs.cn-east-2.myhuaweicloud.com'
|
||
)
|
||
|
||
|
||
def chkData(data):
|
||
res_data = []
|
||
for i in data.values():
|
||
res1 = deepcopy(i)
|
||
if 'interview_type' in res1:
|
||
key1 = res1['interview_type']
|
||
res1['interview_type'] = interview_type_dict.get(key1, '线下面试')
|
||
if 'interview_sign' in res1:
|
||
key2 = res1['interview_sign']
|
||
res1['interview_sign'] = interview_sign_dict.get(key2, '未签到')
|
||
if 'feedback' in res1:
|
||
key3 = res1['feedback']
|
||
res1['feedback'] = feedback_dict.get(key3, '未反馈')
|
||
if 'interview_round' in res1:
|
||
key4 = res1['interview_round']
|
||
res1['interview_round'] = interview_round_dict.get(key4, '初试')
|
||
if 'interview_stage' in res1:
|
||
key5 = res1['interview_stage']
|
||
res1['interview_stage'] = interview_stage_dict.get(key5, '初筛')
|
||
if 'owner_name' in res1:
|
||
key6 = res1['owner_name']
|
||
res1['owner_name'] = owner_name_dict.get(key6, '人才库')
|
||
if 'mmended_state' in res1:
|
||
key8 = res1['mmended_state']
|
||
res1['mmended_state'] = mmended_state_dict.get(key8, '未推荐')
|
||
if 'interview_state' in res1:
|
||
key9 = res1['interview_state']
|
||
res1['interview_state'] = interview_state_dict.get(key9, '待安排')
|
||
if 'men_state' in res1:
|
||
key10 = res1['men_state']
|
||
res1['men_state'] = men_state_dict.get(key10, '未反馈')
|
||
if 'teacher_state' in res1:
|
||
key11 = res1['teacher_state']
|
||
res1['teacher_state'] = teacher_state_dict.get(key11, '未反馈')
|
||
if 'teacher_back' in res1:
|
||
key12 = res1['teacher_back']
|
||
res1['teacher_back'] = teacher_back_dict.get(key12, '非常不满意')
|
||
if 'offer_state' in res1:
|
||
key13 = res1['offer_state']
|
||
res1['offer_state'] = offer_state_dict.get(key13, '未创建')
|
||
if 'offer_exam_state' in res1:
|
||
key14 = res1['offer_exam_state']
|
||
res1['offer_exam_state'] = offer_exam_state_dict.get(key14, '未发起')
|
||
if 'notice_state' in res1:
|
||
key15 = res1['notice_state']
|
||
res1['notice_state'] = notice_state_dict.get(key15, '未通知')
|
||
if 'pass_why' in res1:
|
||
key16 = res1['pass_why']
|
||
res1['pass_why'] = pass_why_dict.get(key16, '')
|
||
if 'work_list' in res1:
|
||
work_list = res1['work_list']
|
||
if work_list:
|
||
work_list = [json.loads(i) for i in work_list]
|
||
if isinstance(work_list[0], str):
|
||
work_list = [eval(i) for i in work_list]
|
||
if len(work_list) > 1:
|
||
true_index = 0
|
||
for index, i in enumerate(work_list):
|
||
if index == 0:
|
||
continue
|
||
if int(i['time'].split('-')[0].replace('.', '').replace('/', '')) > int(
|
||
work_list[true_index]['time'].split('-')[0].replace('.', '').replace('/', '')):
|
||
true_index = index
|
||
work_dict = work_list[true_index]
|
||
work_list = [work_dict]
|
||
else:
|
||
work_list = []
|
||
res1['work_list'] = work_list
|
||
if 'project_undergo' in res1:
|
||
project_undergo = res1['project_undergo']
|
||
if project_undergo:
|
||
project_undergo = [json.loads(i) for i in project_undergo]
|
||
if isinstance(project_undergo[0], str):
|
||
project_undergo = [eval(i) for i in project_undergo]
|
||
else:
|
||
project_undergo = []
|
||
res1['project_undergo'] = project_undergo
|
||
if 'language' in res1:
|
||
language = res1['language']
|
||
if language:
|
||
language = [json.loads(i) for i in language]
|
||
if isinstance(language[0], str):
|
||
language = [eval(i) for i in language]
|
||
else:
|
||
language = []
|
||
res1['language'] = language
|
||
if 'remembrance' in res1:
|
||
remembrance = res1['remembrance']
|
||
if remembrance:
|
||
remembrance = [json.loads(i) for i in remembrance]
|
||
if isinstance(remembrance[0], str):
|
||
remembrance = [eval(i) for i in remembrance]
|
||
else:
|
||
remembrance = []
|
||
res1['remembrance'] = remembrance
|
||
if 'education' in res1:
|
||
education = res1['education']
|
||
res1['education'] = education_dict[education]
|
||
if 'teacher_txt' in res1:
|
||
teacher_txt = res1['teacher_txt']
|
||
if not teacher_txt:
|
||
teacher_txt = teacher_txt
|
||
else:
|
||
teacher_txt = json.loads(teacher_txt)
|
||
res1['teacher_txt'] = teacher_txt
|
||
res_data.append(res1)
|
||
return res_data
|
||
|
||
|
||
# 面试查询
|
||
@router.post("/interview_find")
|
||
async def interview_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# 面试查询
|
||
@router.post("/interview_manner_num")
|
||
async def interview_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_every_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
res_msg = {
|
||
'manner_2_num': 0,
|
||
'manner_01_num': 0,
|
||
}
|
||
return schemas.Msg(code=200, msg='无数据', data=res_msg)
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
|
||
# 统计数量
|
||
manner_2_num = len([1 for i in res_data if i['hr_manner'] == 2])
|
||
manner_01_num = len([1 for i in res_data if i['hr_manner'] in [0, 1]])
|
||
|
||
res_msg = {
|
||
'manner_2_num': manner_2_num,
|
||
'manner_01_num': manner_01_num,
|
||
}
|
||
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
||
|
||
|
||
# 面试_主页初筛查询
|
||
@router.post("/interview_home_find")
|
||
async def interview_home_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据主页初筛查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_home_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# 复筛查询
|
||
@router.post("/interview_screen_find")
|
||
async def interview_screen_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据复筛查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_screen_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# 面试阶段查询
|
||
@router.post("/interview_exam_find")
|
||
async def interview_exam_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据面试阶段查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_exam_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# offer阶段查询
|
||
@router.post("/interview_stage_num")
|
||
async def interview_stage_num(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据offer阶段查询 """
|
||
await interview.init()
|
||
res = interview.find_stage_num_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
res_data = {
|
||
'0': 0,
|
||
'1': 0,
|
||
'2': 0,
|
||
'3': 0,
|
||
'4': 0,
|
||
'5': 0,
|
||
'6': 0,
|
||
'7': 0,
|
||
'8': 0,
|
||
'9': 0,
|
||
'10': 0,
|
||
}
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=res_data)
|
||
for i in data.values():
|
||
key = str(i['interview_stage'])
|
||
if key not in res_data:
|
||
continue
|
||
res_data[key] = i['value']
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# 待入职阶段查询
|
||
@router.post("/interview_waite_in_find")
|
||
async def interview_waite_in_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据待入职阶段查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_waite_in_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = chkData(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
# 面试修改
|
||
@router.post("/interview_update")
|
||
async def interview_update(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据更新 """
|
||
await interview.init()
|
||
res = interview.update_interview_sql()
|
||
sql = res['sql']
|
||
# try:
|
||
data = await db.execute(sql)
|
||
# except:
|
||
# return schemas.Msg(code=-9, msg='数据有误', data=None)
|
||
interviews = int(interview.data.get('interview_stage', '0')) # 简历阶段
|
||
if interview.data_in.get('interview_stage', '') == 11 and interviews > 2: # 淘汰的时候发送钉钉消息通知面试官该求职者被淘汰
|
||
send_sql = f"""
|
||
select interview_id,name,job_names from HR.resumes where uid = '{interview.where.get('uid')}' limit 1
|
||
"""
|
||
interview_id = await db.execute(send_sql)
|
||
userid_list = interview_id[0]['interview_id'].split(',')
|
||
interview_stage = interview_stage_dict[interviews] # 映射简历阶段
|
||
why = pass_why_dict[interview.data_in.get('pass_why')] # 映射淘汰原因
|
||
content = f"""
|
||
【淘汰通知】\n姓名：{interview_id[0]['name']}\n求职岗位：{interview_id[0]['job_names']}\n淘汰原因：{why}\n具体淘汰原因：{interview.data_in.get('pass_text')}\n简历阶段：{interview_stage}\n操作人：{current_user.name}
|
||
"""
|
||
send_dates(content, userid_list)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
# 写入面试数据
|
||
@router.post("/interview_insert")
|
||
async def interview_insert(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据写入 """
|
||
await interview.init()
|
||
res = interview.insert_interview_sql()
|
||
sql = res['sql']
|
||
insert_data = res['insert_data']
|
||
data = await db.execute_dict(sql, insert_data)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
# 转存简历到华为云
|
||
@router.post("/file_to_hw")
|
||
async def file_to_hw(
|
||
request: Request,
|
||
file: UploadFile = File(...),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 简历上传到华为云 """
|
||
path_data = os.getcwd() + '/jianli' # 当前文件所在的目录
|
||
if not os.path.exists(path_data):
|
||
os.makedirs(path_data)
|
||
contents = await file.read()
|
||
filename = file.filename
|
||
try:
|
||
with open(path_data + '/' + filename, "wb") as f:
|
||
# 将获取的file文件内容，写入到新文件中
|
||
f.write(contents)
|
||
f.close()
|
||
except:
|
||
return schemas.Msg(code=400, msg='上传文件有误', data=None)
|
||
|
||
try:
|
||
fn = path_data + '/' + filename
|
||
if fn.endswith('pdf'): # pdf正常上传到华为云
|
||
res = obsClient.putFile('legu-cdn-source', 'hrms/' + filename, path_data + '/' + filename)
|
||
else: # doc/docx则转化为pdf上传到华为云
|
||
new_fn, fil = doc2pdf(fn, path_data, filename)
|
||
filename = fil
|
||
res = obsClient.putFile('legu-cdn-source', 'hrms/' + filename, new_fn)
|
||
if res.status < 300:
|
||
# 地址
|
||
url = res.body.objectUrl
|
||
# 简历初始文档
|
||
data_mode = {
|
||
"interview_name": "",
|
||
"interview_type": 1,
|
||
"interview_sign": 0,
|
||
"hope_money": "",
|
||
"feedback": 0,
|
||
"interview_round": 0,
|
||
"event_time": datetime.now(),
|
||
"name": "",
|
||
"phone": "",
|
||
"job_name": "",
|
||
"hr_name": "",
|
||
"work_exp": 0,
|
||
"interview_stage": 1,
|
||
"owner_name": 2,
|
||
"education": 1,
|
||
"work_undergo": [],
|
||
"project_undergo": [],
|
||
"work_list": [],
|
||
"school": "",
|
||
"at_school": "",
|
||
"specialty": "",
|
||
"specialty_do": [],
|
||
"mmended_state": 0,
|
||
"mail": "",
|
||
"account": "",
|
||
"id_card": "",
|
||
"gender": "",
|
||
"age": 0,
|
||
"gam": "",
|
||
"interview_state": 1,
|
||
"counts": 1,
|
||
"nation": "汉",
|
||
"review": "",
|
||
"upgrade": [],
|
||
"come_time": "",
|
||
"now_money": "",
|
||
"men_state": 1,
|
||
"teacher_state": 1,
|
||
"teacher_back": 1,
|
||
"offer_state": 1,
|
||
"offer_exam_state": 1,
|
||
"notice_state": 1,
|
||
"pass_why": 0,
|
||
"pass_text": "",
|
||
"now_address": "",
|
||
"language": [],
|
||
"remembrance": [],
|
||
"file_url": url,
|
||
"hr_manner": 2,
|
||
}
|
||
uid = get_uid()
|
||
data_mode['uid'] = uid
|
||
sql = f"insert into HR.resumes(interview_name, interview_type, interview_sign, hope_money, feedback," \
|
||
f" interview_round, event_time, uid, name, phone, job_name, hr_name, work_exp, interview_stage, owner_name," \
|
||
f" education, work_undergo, project_undergo, work_list, school, at_school, specialty, specialty_do, " \
|
||
f"mmended_state, mail, account, id_card, gender, age, gam, interview_state, counts, nation, come_time," \
|
||
f" review, upgrade, now_money, men_state, teacher_state, teacher_back, offer_state, offer_exam_state," \
|
||
f" notice_state, pass_why, pass_text, now_address,language,remembrance, file_url, hr_manner) values"
|
||
# 存数据
|
||
chk_txt = getText_pdf(path_data + '/' + filename)
|
||
data = fmt_txt(chk_txt)
|
||
education = data['education']
|
||
# 学历int转化
|
||
education_int = {
|
||
'大专': 1,
|
||
'本科': 2,
|
||
'研究生': 3,
|
||
'博士': 4,
|
||
'硕士': 5,
|
||
}
|
||
if education and isinstance(education, str):
|
||
data['education'] = education_int.get(education, 1)
|
||
age = data['age']
|
||
if not age:
|
||
data['age'] = 20
|
||
# 年龄int转化
|
||
if age and isinstance(age, str):
|
||
true_age = re.search(r"\d+\.?\d*", age)
|
||
if len(true_age.group()) > 2:
|
||
data['age'] = 20
|
||
else:
|
||
data['age'] = int(true_age.group())
|
||
work_exp = data['work_exp']
|
||
if not work_exp:
|
||
data['work_exp'] = 0
|
||
# 工作经验float转化
|
||
if work_exp and isinstance(work_exp, str):
|
||
true_work_exp = re.search(r"\d+\.?\d*", work_exp)
|
||
if len(true_work_exp.group()) > 3:
|
||
data['work_exp'] = 0
|
||
else:
|
||
data['work_exp'] = float(true_work_exp.group())
|
||
|
||
data_mode.update(data)
|
||
# 转json字符串
|
||
if 'remembrance_list' in data_mode:
|
||
remembrance = data_mode.pop('remembrance_list')
|
||
data_mode['remembrance'] = remembrance
|
||
if 'language_list' in data_mode:
|
||
language = data_mode.pop('language_list')
|
||
data_mode['language'] = language
|
||
if 'project_undergo' in data_mode:
|
||
if data_mode.get('project_undergo', []):
|
||
data_mode['project_undergo'] = [json.dumps(i) for i in data_mode['project_undergo']]
|
||
else:
|
||
data_mode['project_undergo'] = []
|
||
if 'work_list' in data_mode:
|
||
if data_mode.get('work_list', []):
|
||
data_mode['work_list'] = [json.dumps(i) for i in data_mode['work_list']]
|
||
else:
|
||
data_mode['work_list'] = []
|
||
if 'language' in data_mode:
|
||
if data_mode.get('language', []):
|
||
data_mode['language'] = [json.dumps(i) for i in data_mode['language']]
|
||
else:
|
||
data_mode['language'] = []
|
||
if 'remembrance' in data_mode:
|
||
if data_mode.get('remembrance', []):
|
||
data_mode['remembrance'] = [json.dumps(i) for i in data_mode['remembrance']]
|
||
else:
|
||
data_mode['remembrance'] = []
|
||
|
||
# 字符串转datetime
|
||
if data_mode.get('in_time', ''):
|
||
chk_in_time = data_mode['in_time'].replace('-', '/').replace('.', '/')
|
||
if len(chk_in_time.split('/')) == 2:
|
||
data_mode['in_time'] = str(datetime.strptime(chk_in_time, "%Y/%m").date())
|
||
if len(chk_in_time.split('/')) == 3:
|
||
data_mode['in_time'] = str(datetime.strptime(chk_in_time, "%Y/%m/%d").date())
|
||
|
||
if data_mode.get('out_time', ''):
|
||
chk_out_time = data_mode['out_time'].replace('-', '/').replace('.', '/')
|
||
if len(chk_out_time.split('/')) == 2:
|
||
data_mode['out_time'] = str(datetime.strptime(chk_out_time, "%Y/%m").date())
|
||
if len(chk_out_time.split('/')) == 3:
|
||
data_mode['out_time'] = str(datetime.strptime(chk_out_time, "%Y/%m/%d").date())
|
||
|
||
if data_mode.get('birthday', ''):
|
||
chk_birthday = data_mode['birthday'].replace('-', '/').replace('.', '/')
|
||
if len(chk_birthday.split('/')) == 2:
|
||
data_mode['birthday'] = str(datetime.strptime(chk_birthday, "%Y/%m").date())
|
||
if len(chk_birthday.split('/')) == 3:
|
||
data_mode['birthday'] = str(datetime.strptime(chk_birthday, "%Y/%m/%d").date())
|
||
|
||
if data_mode.get('star_time', ''):
|
||
chk_star_time = data_mode['star_time'].replace('-', '/').replace('.', '/')
|
||
if len(chk_star_time.split('/')) == 2:
|
||
data_mode['star_time'] = str(datetime.strptime(chk_star_time, "%Y/%m").date())
|
||
if len(chk_star_time.split('/')) == 3:
|
||
data_mode['star_time'] = str(datetime.strptime(chk_star_time, "%Y/%m/%d").date())
|
||
|
||
if data_mode.get('end_time', ''):
|
||
chk_end_time = data_mode['end_time'].replace('-', '/').replace('.', '/')
|
||
if len(chk_end_time.split('/')) == 2:
|
||
data_mode['end_time'] = str(datetime.strptime(chk_end_time, "%Y/%m").date())
|
||
if len(chk_end_time.split('/')) == 3:
|
||
data_mode['end_time'] = str(datetime.strptime(chk_end_time, "%Y/%m/%d").date())
|
||
|
||
if data_mode.get('graduate_time', ''):
|
||
chk_graduate = data_mode['graduate_time'].replace('-', '/').replace('.', '/')
|
||
if len(chk_graduate.split('/')) == 2:
|
||
data_mode['graduate_time'] = str(datetime.strptime(chk_graduate, "%Y/%m").date())
|
||
if len(chk_graduate.split('/')) == 3:
|
||
data_mode['graduate_time'] = str(datetime.strptime(chk_graduate, "%Y/%m/%d").date())
|
||
|
||
work_list = data['work_list']
|
||
language = data['language']
|
||
project_undergo = data['project_undergo']
|
||
remembrance = data['remembrance']
|
||
|
||
res_data = {
|
||
'data': data,
|
||
'file_url': url,
|
||
'uid': uid,
|
||
'project_undergo': project_undergo,
|
||
'work_list': work_list,
|
||
'language_list': language,
|
||
'remembrance_list': remembrance
|
||
}
|
||
await db.execute_dict(sql, [data_mode])
|
||
return schemas.Msg(code=0, msg='ok', data=res_data)
|
||
else:
|
||
print('errorCode:', res.errorCode)
|
||
print('errorMessage:', res.errorMessage)
|
||
return schemas.Msg(code=400, msg='上传华为云失败', data=None)
|
||
except:
|
||
return schemas.Msg(code=400, msg='上传华为云失败或者解析失败', data=None)
|
||
|
||
|
||
# 导入面试数据
|
||
@router.post("/interview_file_insert")
|
||
async def interview_file_insert(
|
||
request: Request,
|
||
data_in: schemas.Filenames,
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据导入 """
|
||
path_data = os.getcwd() + '/jianli' # 当前文件所在的目录
|
||
if not os.path.exists(path_data):
|
||
os.makedirs(path_data)
|
||
filename = data_in.filenames.split('/')[-1]
|
||
try:
|
||
res = obsClient.getObject('legu-cdn-source', data_in.filenames, path_data + '/' + filename)
|
||
if res.status < 300:
|
||
chk_txt = getText_pdf(path_data + '/' + filename)
|
||
data = fmt_txt(chk_txt)
|
||
education = data['education']
|
||
# 学历int转化
|
||
education_int = {
|
||
'大专': 1,
|
||
'本科': 2,
|
||
'研究生': 3,
|
||
'博士': 4,
|
||
'硕士': 5,
|
||
}
|
||
if education and isinstance(education, str):
|
||
data['education'] = education_int.get(education, 1)
|
||
age = data['age']
|
||
if not age:
|
||
data['age'] = 20
|
||
# 年龄int转化
|
||
if age and isinstance(age, str):
|
||
true_age = re.search(r"\d+\.?\d*", age)
|
||
if len(true_age.group()) > 2:
|
||
data['age'] = 20
|
||
else:
|
||
data['age'] = int(true_age.group())
|
||
work_exp = data['work_exp']
|
||
if not work_exp:
|
||
data['work_exp'] = 0
|
||
# 工作经验float转化
|
||
if work_exp and isinstance(work_exp, str):
|
||
true_work_exp = re.search(r"\d+\.?\d*", work_exp)
|
||
if len(true_work_exp.group()) > 3:
|
||
data['work_exp'] = 0
|
||
else:
|
||
data['work_exp'] = float(true_work_exp.group())
|
||
|
||
print(data)
|
||
|
||
work_list = data['work_list']
|
||
language = data['language']
|
||
project_undergo = data['project_undergo']
|
||
remembrance = data['remembrance']
|
||
|
||
res_data = {
|
||
'data': data,
|
||
'project_undergo': project_undergo,
|
||
'work_list': work_list,
|
||
'language_list': language,
|
||
'remembrance_list': remembrance
|
||
}
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
else:
|
||
return schemas.Msg(code=-9, msg='解析失败', data='')
|
||
except:
|
||
return schemas.Msg(code=-9, msg='解析失败', data='')
|
||
|
||
|
||
@router.post("/add_job")
|
||
async def add_job(
|
||
request: Request,
|
||
data_in: schemas.Ins_Job,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""新增职位"""
|
||
await crud.jobs.insert_job(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/find_job")
|
||
async def find_job(
|
||
request: Request,
|
||
data_in: schemas.Find_job,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取单个职位信息"""
|
||
res = await crud.jobs.find_job(db, data_in.job_id)
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
@router.post("/condition")
|
||
async def condition(
|
||
request: Request,
|
||
data_in: schemas.Interview,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 面试情况 """
|
||
res = data_in.date
|
||
strs = []
|
||
for k, v in res.items():
|
||
if v != '':
|
||
if 'int' in str(type(v)):
|
||
str_s = f"{k} = {v}"
|
||
strs.append(str_s)
|
||
else:
|
||
if k in ['hr_id', 'interview_id', 'interview_name', 'hr_name'] and v != '':
|
||
str_s = f"{k} like '%{v}%'"
|
||
else:
|
||
str_s = f"{k} = '{v}'"
|
||
strs.append(str_s)
|
||
where = ' and '.join(strs)
|
||
# 当前日期
|
||
times = get_time()
|
||
# 今天的面试
|
||
if data_in.time_type == 'now':
|
||
# 查询返回的数据一共多少条
|
||
len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) == '{times}' and interview_stage = 3 ORDER BY event_time"""
|
||
sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_names,hr_name,uid,interview_id,
|
||
feedback,interview_name from HR.resumes where {where} and toDate(star_time) == '{times}' and interview_stage = 3 ORDER BY event_time
|
||
LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
|
||
# 明天及之后的面试
|
||
elif data_in.time_type == 'tomorrow':
|
||
len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) > '{times}' and interview_stage = 3 ORDER BY event_time"""
|
||
sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_names,hr_name,uid,interview_id,
|
||
feedback,interview_name from HR.resumes where {where} and toDate(star_time) > '{times}' and interview_stage = 3 ORDER BY event_time
|
||
LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
|
||
# 今天及之后的面试
|
||
elif data_in.time_type == 'later':
|
||
len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) > '{times}' and interview_stage = 3 ORDER BY event_time"""
|
||
sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_names,hr_name,uid,interview_id,
|
||
feedback,interview_name from HR.resumes where {where} and toDate(star_time) >= '{times}' and interview_stage = 3 ORDER BY event_time
|
||
LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
|
||
# 昨天及以前的面试
|
||
else:
|
||
len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) < '{times}' ORDER BY event_time"""
|
||
sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_names,hr_name,uid,interview_id,
|
||
feedback,interview_name from HR.resumes where {where} and toDate(star_time) < '{times}' ORDER BY event_time
|
||
LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
|
||
if where == '':
|
||
len_sql = len_sql.replace('where and', 'where', 1)
|
||
sql = sql.replace('where and', 'where', 1)
|
||
# 返回数据条数
|
||
df_len = await ckdb.query_dataframe(len_sql)
|
||
len_date = len(df_len)
|
||
df = await ckdb.query_dataframe(sql)
|
||
if df.empty:
|
||
data = {'lens': 0,
|
||
'data': []
|
||
}
|
||
return schemas.Msg(code=200, msg='无数据', data=data)
|
||
datas = []
|
||
for i in range(len(df)):
|
||
dates = {}
|
||
dates['key'] = df['uid'][i]
|
||
date = {} # 面试信息
|
||
date['interview_round'] = int(df['interview_round'][i])
|
||
date['interview_type'] = int(df['interview_type'][i])
|
||
noe = str(df['end_time'][i]).split(' ')[-1]
|
||
timess = str(df['star_time'][i]) + '~' + noe
|
||
date['time'] = timess
|
||
dates['msg'] = date
|
||
dates['name'] = df['name'][i]
|
||
dates['phone'] = df['phone'][i]
|
||
dates['job_names'] = df['job_names'][i]
|
||
dates['hr_name'] = df['hr_name'][i]
|
||
date1 = {}
|
||
date1['type'] = int(df['feedback'][i])
|
||
date1['name'] = df['interview_name'][i]
|
||
dates['type'] = date1
|
||
dates['interview_id'] = df['interview_id'][i]
|
||
datas.append(dates)
|
||
data = {'lens': len_date,
|
||
'data': datas
|
||
}
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/get_job")
|
||
async def get_job(
|
||
request: Request,
|
||
data_in: schemas.Jobs = None,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取职位名称"""
|
||
# 获取对应条件的职位
|
||
res = await crud.jobs.all_fields(db, data_in)
|
||
# 获取职位数量
|
||
if data_in != None:
|
||
if data_in.state == True:
|
||
nums = len(res)
|
||
ress = await crud.jobs.all_fields(db, schemas.Jobs(state=False))
|
||
number = len(ress)
|
||
else:
|
||
number = len(res)
|
||
ress = await crud.jobs.all_fields(db, schemas.Jobs(state=True))
|
||
nums = len(ress)
|
||
job = []
|
||
for i in res:
|
||
# 获取职位名称
|
||
job_list = {}
|
||
job_list['key'] = i['job_id'] # 职位id
|
||
# 查询对应职位id入职多少人
|
||
sql = f"""
|
||
select count(job_id) as nu from HR.resumes where job_id = '{i['job_id']}' and interview_stage = 7
|
||
"""
|
||
num = await ckdb.execute(sql)
|
||
# 候选人总数
|
||
sql1 = f"""
|
||
select count(job_id) as nu from HR.resumes where job_id = '{i['job_id']}' and interview_stage < 6
|
||
"""
|
||
hou_num = await ckdb.execute(sql1)
|
||
job_list['job_name'] = i['job_name'] # 职位名
|
||
job_list['principal'] = i['principal'] # 招聘负责人
|
||
job_list['job_sector'] = i['job_sector'] # 部门
|
||
job_list['job_num'] = i['job_num'] # 目标招聘人数
|
||
job_list['now_job_num'] = num[0]['nu'] # 对应职位的入职人数
|
||
job_list['hou_num'] = hou_num[0]['nu'] # 候选人总数
|
||
job.append(job_list)
|
||
if data_in != None:
|
||
data = {
|
||
'start_num': nums,
|
||
'end_num': number,
|
||
'job': job
|
||
}
|
||
else:
|
||
data = {'job': job}
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/download_interview")
|
||
async def download_interview(
|
||
request: Request,
|
||
data_in: schemas.Timesinter,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""导出所有面试安排"""
|
||
sql = f"""SELECT interview_type,interview_stage,star_time,end_time,name,phone,job_name,hr_name,interview_name,
|
||
interview_sign FROM HR.resumes WHERE toDate(star_time) >= '{data_in.start_time}' and toDate(star_time) <= '{data_in.end_time}'"""
|
||
df = await ckdb.query_dataframe(sql)
|
||
if df.empty:
|
||
return schemas.Msg(code=200, msg='无数据', data='')
|
||
# xlsx表名
|
||
xlsx_name = data_in.start_time + '~' + data_in.end_time + '(包含起止日)'
|
||
datas = []
|
||
for i in range(len(df)):
|
||
one_data = []
|
||
one_data.append(interview_type_dict[df['interview_type'][i]])
|
||
one_data.append(interview_stage_dict[df['interview_stage'][i]])
|
||
df_time = qujian_time(df['star_time'][i], df['end_time'][i])
|
||
one_data.append(df_time)
|
||
one_data.append(df['name'][i])
|
||
one_data.append(df['phone'][i])
|
||
one_data.append(df['job_name'][i])
|
||
one_data.append(df['hr_name'][i])
|
||
one_data.append(df['interview_name'][i])
|
||
one_data.append(interview_sign_dict[df['interview_sign'][i]])
|
||
datas.append(one_data)
|
||
columns = ['面试类型', '面试阶段', '面试时间', '候选人', '联系方式', '应聘职位', '面试负责人', '面试官', '面试签到']
|
||
dfmi = pd.DataFrame(data=datas, columns=columns)
|
||
Download = Download_xlsx(dfmi, xlsx_name)
|
||
return Download
|
||
|
||
|
||
@router.post("/add_remark")
|
||
async def add_remark(
|
||
request: Request,
|
||
data_in: schemas.BaseRemark,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""添加备注"""
|
||
await crud.api_interview_remark.insert_remark(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/find_remark")
|
||
async def find_remark(
|
||
request: Request,
|
||
data_in: schemas.FindRemark,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""查找备注"""
|
||
data = await crud.api_interview_remark.get_interview_remarks(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/find_criterion")
|
||
async def find_criterion(
|
||
request: Request,
|
||
data_in: schemas.get_uids,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取标准版简历"""
|
||
# sql = f"""
|
||
# select name,phone,job_name,work_exp,owner_name,education,work_undergo,school,specialty,
|
||
# graduate_time,mail,account,id_card,gender,nation,age,at_school,specialty_do,hope_money,resume_affix_id,
|
||
# review,work_list,project_undergo,upgrade,come_time,now_money,work_in_time from HR.resumes WHERE uid = '{data_in.uid}'
|
||
# """
|
||
sql = f"""
|
||
select * from HR.resumes WHERE uid = '{data_in.uid}' limit 1
|
||
"""
|
||
df = await ckdb.query_dataframe(sql)
|
||
data = {}
|
||
column = df.columns
|
||
for i in column:
|
||
if 'int' in str(type(df[i][0])):
|
||
data[i] = int(df[i][0])
|
||
else:
|
||
data[i] = df[i][0]
|
||
# if data['work_exp'] == 0:
|
||
# data['work_exp'] = '应届生'
|
||
# elif data['work_exp'] >= 1 and data['work_exp'] < 3:
|
||
# data['work_exp'] = '1-3年'
|
||
# elif data['work_exp'] >= 3 and data['work_exp'] < 5:
|
||
# data['work_exp'] = '1-3年'
|
||
# else:
|
||
# data['work_exp'] = '5年以上'
|
||
if data.get('work_list', []):
|
||
work_list = [json.loads(i) for i in data['work_list']]
|
||
if isinstance(work_list[0], str):
|
||
work_list = [eval(i) for i in work_list]
|
||
data['work_list'] = work_list
|
||
if data.get('project_undergo', []):
|
||
project_undergo = [json.loads(i) for i in data['project_undergo']]
|
||
if isinstance(project_undergo[0], str):
|
||
project_undergo = [eval(i) for i in project_undergo]
|
||
data['project_undergo'] = project_undergo
|
||
if data.get('remembrance', []):
|
||
remembrance = [json.loads(i) for i in data['remembrance']]
|
||
if isinstance(remembrance[0], str):
|
||
remembrance = [eval(i) for i in remembrance]
|
||
data['remembrance'] = remembrance
|
||
data['remembrance_list'] = remembrance
|
||
if data.get('language', []):
|
||
language = [json.loads(i) for i in data['language']]
|
||
if isinstance(language[0], str):
|
||
language = [eval(i) for i in language]
|
||
data['language'] = language
|
||
data['language_list'] = language
|
||
res_data = {k: v for k, v in data.items() if k not in ['event_time']}
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
@router.post("/resume_affix")
|
||
async def resume_affix(
|
||
request: Request,
|
||
data_in: schemas.Post_uid,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""保存附件id"""
|
||
sql = f"""
|
||
ALTER table HR.resumes update resume_affix_id = {data_in.resume_affix_id} WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/updata_entry")
|
||
async def updata_entry(
|
||
request: Request,
|
||
data_in: schemas.Entry,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""修改入职状态"""
|
||
sql = f"""
|
||
ALTER table HR.resumes update interview_stage = {data_in.interview_stage} WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
# 给招聘中职位计入职数
|
||
res = await crud.jobs.find_job(db, data_in.job_id)
|
||
num = res['now_job_num'] + 1
|
||
await crud.jobs.update_job(db, schemas.Jobs(job_id=data_in.job_id, now_job_num=num))
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/get_str_mail")
|
||
async def get_str_mail(
|
||
request: Request,
|
||
data_in: schemas.Email_str,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取邮件文本"""
|
||
data = [f"""
|
||
{data_in.name},您好\n\n感谢关注乐谷在线科技有限公司！很高兴的通知您通过了我们的面试，真诚的邀请您加入我们的团队\n职位：{data_in.job}\n入职时间：{data_in.times}
|
||
\n薪酬：{data_in.money}\n联系人：{data_in.hr_name}\n联系电话：{data_in.phone}\n联系邮箱：{data_in.email}\n\n如有问题请用以上联系方式及时与我们沟通，谢谢！\n（系统邮件，请勿回复）
|
||
""",
|
||
f"""
|
||
{data_in.name},您好\n\n感谢关注乐谷在线科技有限公司！很高兴收到您的简\n历，想和您就{data_in.job}职位安排一次面试。\n\n1.面试日期：{data_in.times}
|
||
\n2.面试时长：30分钟（可能视面试情况缩减或延长，请预留一定缓冲时间）\n3.面试形式：现场面试\n4.面试地址：武汉市洪山区野芷湖西路创意天地5号楼2层\n\n
|
||
联系人：{data_in.hr_name}\n联系电话：{data_in.phone}\n联系邮箱：{data_in.email}\n\n以上面试信息，如需另行安排时间请用以上联系方式及时与我们沟通，谢谢！\n（系统邮件，请勿回复）
|
||
"""
|
||
]
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/send_str_mail")
|
||
async def send_mail(
|
||
request: Request,
|
||
data_in: schemas.send_str_mail,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""发送邮件"""
|
||
try:
|
||
# 发送邮件
|
||
send_str_mail(data_in.email_str, data_in.email)
|
||
# 保存发送邮件的记录
|
||
now_time = str(datetime.now()).split('.')[0]
|
||
await crud.email_record.create(db, schemas.email_record(user_id=data_in.user_id, text=data_in.email_str,
|
||
times=now_time, name=data_in.name, state=1,
|
||
read_status=0, type='email'))
|
||
return schemas.Msg(code=200, msg='邮件发送成功', data='')
|
||
except Exception:
|
||
now_time = str(datetime.now()).split('.')[0]
|
||
await crud.email_record.create(db, schemas.email_record(user_id=data_in.user_id, text=data_in.email_str,
|
||
times=now_time, name=data_in.name, state=0,
|
||
read_status=0, type='email'))
|
||
return schemas.Msg(code=200, msg='邮件发送失败', data='')
|
||
|
||
|
||
@router.post("/email_record")
|
||
async def email_record(
|
||
request: Request,
|
||
data_in: schemas.get_email_record,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取发送邮件的记录"""
|
||
data = await crud.email_record.all_record(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/operate_log")
|
||
async def operate_log(
|
||
request: Request,
|
||
data_in: schemas.operate_log,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""同步插入操作记录"""
|
||
await crud.operate_log.create(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/get_operate_log")
|
||
async def get_operate_log(
|
||
request: Request,
|
||
data_in: schemas.get_operate_log,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取操作记录"""
|
||
data = await crud.operate_log.all_log(db, data_in)
|
||
# 对时间进行排序
|
||
data = sorted(data, key=operator.itemgetter('times'))
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.get("/get_dding_user")
|
||
async def get_dding_user(
|
||
request: Request,
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取钉钉的用户id"""
|
||
data = get_redis_alluid()
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/teacher_state")
|
||
async def teacher_state(
|
||
request: Request,
|
||
data_in: schemas.user_id,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""催促面试官反馈功能"""
|
||
# 同步钉钉发消息给面试官
|
||
try:
|
||
now_time = str(datetime.now()).split('.')[0]
|
||
content = f"【催促反馈】\n请面试官尽快给{data_in.name}做面试反馈\n提醒时间：{now_time}"
|
||
send_dates(content, data_in.user_id)
|
||
return schemas.Msg(code=200, msg='发送成功', data='')
|
||
except Exception:
|
||
return schemas.Msg(code=-9, msg='发送失败', data='')
|
||
|
||
|
||
@router.post("/add_mode")
|
||
async def add_mode(
|
||
request: Request,
|
||
data_in: schemas.InsertModes,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""添加hr分组"""
|
||
await crud.api_interview_modes.insert_modes(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/add_table")
|
||
async def add_table(
|
||
request: Request,
|
||
data_in: schemas.InsertTables,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""添加分组报表"""
|
||
await crud.api_interview_tables.insert_tables(db, data_in)
|
||
mode_id = data_in.mode_id
|
||
mode_info = await crud.api_interview_modes.get_one_mode(db, mode_id)
|
||
mode_list = mode_info.get('mode_list', [])
|
||
table_id = data_in.table_id
|
||
# 不存在则添加
|
||
if table_id not in mode_list:
|
||
mode_list.append(table_id)
|
||
await crud.api_interview_modes.update_mode_list(db, mode_id, mode_list)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/update_table")
|
||
async def update_table(
|
||
request: Request,
|
||
data_in: schemas.UpdateTables,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""修改表报"""
|
||
await crud.api_interview_tables.update_tables(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/find_mode")
|
||
async def find_mode(
|
||
request: Request,
|
||
data_in: schemas.FindModes,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""查找hr所有分组"""
|
||
data = await crud.api_interview_modes.get_interview_modes(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/find_mode_tables")
|
||
async def find_mode_tables(
|
||
request: Request,
|
||
data_in: schemas.UpdateModes,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取一条hr分组包含的报表"""
|
||
mode_data = await crud.api_interview_modes.get_one_mode(db, data_in.mode_id)
|
||
table_data = []
|
||
new_table_data = []
|
||
if mode_data:
|
||
tables = mode_data['mode_list']
|
||
if tables:
|
||
table_data = await crud.api_interview_tables.get_tables(db, {'table_id': {'$in': tables}})
|
||
if table_data:
|
||
for data in table_data:
|
||
table_id = data.get('table_id')
|
||
sort_key = tables.index(table_id)
|
||
data.update({'sort_key': sort_key})
|
||
new_data = deepcopy(data)
|
||
new_table_data.append(new_data)
|
||
if new_table_data:
|
||
new_table_data.sort(key=lambda i: i.get('sort_key'))
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=new_table_data)
|
||
|
||
|
||
@router.post("/update_mode")
|
||
async def update_mode(
|
||
request: Request,
|
||
data_in: schemas.UpdateModes,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""更新一条hr分组数据"""
|
||
await crud.api_interview_modes.update_modes(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.get("/name")
|
||
async def name(
|
||
request: Request,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取所有用户角色"""
|
||
res = await crud.user.get_all_users(db, {})
|
||
data = []
|
||
for i in res:
|
||
if i.get('name') != 'root':
|
||
data_dict = {}
|
||
data_dict['_id'] = i.get('_id')
|
||
data_dict['name'] = i.get('name')
|
||
data_dict['user_id'] = i.get('user_id')
|
||
data_dict['email'] = i.get('email')
|
||
data_dict['rank'] = i.get('rank') # 用于区分是面试官还是hr
|
||
data.append(data_dict)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/amend_job")
|
||
async def amend_job(
|
||
request: Request,
|
||
data_in: schemas.Jobs,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""修改职位信息，修改职位招聘状态"""
|
||
await crud.jobs.update_job(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/create")
|
||
async def create(
|
||
request: Request,
|
||
data_in: schemas.DashboardCreate,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""创建看板"""
|
||
try:
|
||
await crud.dashboard.create(db, data_in.name, user_id=current_user.id)
|
||
except pymongo.errors.DuplicateKeyError:
|
||
return schemas.Msg(code=-1, msg='看板已存在', data='看板已存在')
|
||
|
||
return schemas.Msg(code=200, msg='ok', data='创建成功')
|
||
|
||
|
||
@router.post("/delete")
|
||
async def delete(
|
||
request: Request,
|
||
data_in: schemas.DashboardDelete,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""删除看板"""
|
||
del_dashboard = await crud.dashboard.delete(db, {'_id': {'$in': data_in.ids}})
|
||
if del_dashboard.deleted_count == 0:
|
||
return schemas.Msg(code=-1, msg='error', data='删除失败')
|
||
return schemas.Msg(code=200, msg='ok', data='删除成功')
|
||
|
||
|
||
@router.post("/get_dashboard")
|
||
async def get_dashboard(
|
||
request: Request,
|
||
data_in: schemas.ReadDashboard,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""获取一个看板"""
|
||
res = await crud.dashboard.get(db, id=data_in.id)
|
||
reports = {item['report_id']: item for item in res['reports']}
|
||
reports_detail = await crud.report.find_many(db, {'_id': {'$in': list(reports.keys())}}, {'query.cachedata': False})
|
||
for item in reports_detail:
|
||
reports[item['_id']].update(item)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/edit")
|
||
async def edit(
|
||
request: Request,
|
||
data_in: schemas.EditDashboard,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""编辑看板名"""
|
||
await crud.dashboard.update_one(db, {'_id': data_in.dashboard_id}, {'$set': {'name': data_in.new_name}})
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/notarize")
|
||
async def notarize(
|
||
request: Request,
|
||
data_in: schemas.Notarize,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""简历确认进入面试阶段"""
|
||
sql = f"""
|
||
ALTER table HR.resumes update interview_state = 2,hr_name = '{data_in.hr_name}',hr_id = '{data_in.hr_id}',interview_name = '{data_in.interview_name}',interview_id = '{data_in.interview_id}' WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
find_sql = f"""
|
||
select uid,name,interview_name,hr_name,star_time,interview_sign,job_id,job_names,mail from HR.resumes where uid = '{data_in.uid}'
|
||
"""
|
||
df = await ckdb.query_dataframe(find_sql)
|
||
# 存份面试数据到mongodb
|
||
now_time = str(datetime.now()).split('.')[0]
|
||
await crud.interview_record.insert_record(db, schemas.interview_record(uid=df['uid'][0], # 唯一id
|
||
name=df['name'][0], # 求职者姓名
|
||
interview_name=df['interview_name'][0],
|
||
# 面试官姓名
|
||
hr_name=df['hr_name'][0], # hr姓名
|
||
star_time=df['star_time'][0], # 开始面试时间
|
||
interview_sign=0, # 签到状态
|
||
job_id=df['job_id'][0], # 我们自己招聘的职位id
|
||
job_names=df['job_names'][0], # 我们自己招聘的职位名
|
||
times=now_time, # 创建数据日期
|
||
read_status=0, # 读取状态
|
||
type='interview' # 记录的类型
|
||
))
|
||
if df['mail'][0] != '':
|
||
# 发送邮件给面试者通知面试
|
||
msg = f"""{df['name'][0]},您好\n\n感谢关注乐谷在线科技有限公司！请于{df['star_time'][0]}到公司参见面试。\n联系人：{data_in.hr_name}\n联系电话：{data_in.hr_phone}\n联系邮箱：{
|
||
data_in.hr_email}\n\n如有问题请用以上联系方式及时与我们沟通，谢谢！\n（系统邮件，请勿回复）
|
||
"""
|
||
send_str_mail(msg, df['mail'][0])
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/alter")
|
||
async def alter(
|
||
request: Request,
|
||
data_in: schemas.Stage,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""更改简历阶段"""
|
||
if data_in.stage == 1: # 初筛
|
||
sql = f"""
|
||
ALTER table HR.resumes update interview_stage = 1,job_id = '{data_in.data['job_id']}',job_names = '{data_in.data['job_names']}' WHERE uid = '{data_in.uid}'
|
||
"""
|
||
else:
|
||
sql = f"""
|
||
ALTER table HR.resumes update interview_stage = {data_in.stage} WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/get_report")
|
||
async def get_report(
|
||
request: Request,
|
||
data_in: schemas.Findreport,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获得已添加的报表"""
|
||
# 获取自己的报表
|
||
res = await crud.dashboard.find_report(db, user_id=data_in.report_id)
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
@router.post("/create_report")
|
||
async def create_report(
|
||
request: Request,
|
||
data_in: schemas.ReportCreate,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""新建报表"""
|
||
try:
|
||
await crud.report.create(db, data_in)
|
||
except pymongo.errors.DuplicateKeyError:
|
||
return schemas.Msg(code=-9, msg='error', data='报表已存在')
|
||
return schemas.Msg(code=200, msg='创建成功', data='')
|
||
|
||
|
||
@router.post("/up_report")
|
||
async def up_report(
|
||
request: Request,
|
||
data_in: schemas.ReportEdit,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""编辑报表"""
|
||
await crud.report.update_one(db, {'_id': data_in.report_id},
|
||
{'$set': {'query': data_in.query, 'name': data_in.name, 'desc': data_in.desc}})
|
||
# 只能报表所有者编辑
|
||
# res = await crud.report.update_one(db, {'_id': data_in.report_id, 'user_id': request.user.id},
|
||
# {'$set': {'query': data_in.query, 'name': data_in.name, 'desc': data_in.desc}})
|
||
|
||
# if not res.matched_count:
|
||
# #if res.matched_count:
|
||
# return schemas.Msg(code=-1, msg='只能报表所有者编辑')
|
||
return schemas.Msg(code=200, msg='编辑成功', data='')
|
||
|
||
|
||
@router.post("/edit_report")
|
||
async def edit_report(
|
||
request: Request,
|
||
data_in: schemas.EditReport,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""看板样式设置"""
|
||
await crud.dashboard.update_one(db, {'_id': data_in.id, 'reports.report_id': data_in.report.report_id},
|
||
{'$set': {f'reports.$.{k}': v for k, v in
|
||
data_in.report.dict(skip_defaults=True).items()}})
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/head")
|
||
async def head(
|
||
request: Request,
|
||
data_in: schemas.Post_head,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""保存头像链接"""
|
||
sql = f"""
|
||
ALTER table HR.resumes update head = '{data_in.head_id}' WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.get("/hint")
|
||
async def hint(
|
||
request: Request,
|
||
data_in: schemas.Get_hr,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""重要事项-面试相关"""
|
||
# 邮件，反馈
|
||
res = await crud.email_record.all_hint(db)
|
||
# 面试记录
|
||
interview = await crud.interview_record.all_fields(db, {'hr_name': data_in.hr_name})
|
||
for i in interview:
|
||
res.append(i)
|
||
data = sorted(res, key=operator.itemgetter('times'))
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/up_hint")
|
||
async def up_hint(
|
||
request: Request,
|
||
data_in: schemas.Up_hint,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""批量修改已读状态"""
|
||
# 面试记录
|
||
if data_in.type == 'interview':
|
||
await crud.interview_record.up_interview(db, data_in)
|
||
# 邮件，反馈
|
||
else:
|
||
await crud.email_record.up_hint(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/login")
|
||
async def login(
|
||
# data_in: schemas.Login,
|
||
data: ExtendendOAuth = Depends(),
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
) -> Any:
|
||
"""
|
||
OAuth2兼容令牌登录，获取将来令牌的访问令牌
|
||
"""
|
||
if data.unionid == None:
|
||
# 账号密码登录
|
||
user = await crud.user.authenticate(db,
|
||
name=data.username, password=data.password
|
||
)
|
||
if not user:
|
||
# raise HTTPException(status_code=400, detail="Incorrect name or password")
|
||
return schemas.Msg(code=-1, msg='密码或用户名错误')
|
||
access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
|
||
# access_token_expires = timedelta(seconds=5)
|
||
await crud.user.update_login_time(db, data.username)
|
||
else:
|
||
# 钉钉扫码登录
|
||
user_id = Unionid(data.unionid)
|
||
user_list = get_alluid_list()
|
||
if user_id not in user_list:
|
||
return schemas.Msg(code=-1, msg='密码或用户名错误')
|
||
user = await crud.user.gets_user(db, user_id=user_id)
|
||
if user.state == 1:
|
||
return schemas.Msg(code=-1, msg='您的账号已被锁定，请联系管理员解锁')
|
||
access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
|
||
await crud.user.update_login_time(db, user.id) # 更新最后一次登录时间
|
||
return {
|
||
'data': {
|
||
'name': user.name, # 名字
|
||
'email': user.email, # 邮箱
|
||
'tel': user.tel, # 电话
|
||
'user_id': user.user_id, # 钉钉id
|
||
'id': user.id, # 账号的唯一标识
|
||
'rank': user.rank, # 区分hr和面试官
|
||
'token': security.create_access_token(
|
||
expires_delta=access_token_expires, user_id=user.user_id, email=user.email,
|
||
tel=user.tel, name=user.name, rank=user.rank),
|
||
"token_type": "bearer"},
|
||
'access_token': security.create_access_token(
|
||
expires_delta=access_token_expires, user_id=user.user_id, email=user.email,
|
||
tel=user.tel, name=user.name, rank=user.rank
|
||
),
|
||
"token_type": "bearer",
|
||
'code': 200,
|
||
'msg': 'success',
|
||
}
|
||
|
||
|
||
@router.post("/reset_password")
|
||
async def reset_password(request: Request,
|
||
data_in: schemas.UserRestPassword,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> Any:
|
||
"""
|
||
修改其他人密码
|
||
"""
|
||
try:
|
||
await crud.user.reset_password(db, data_in)
|
||
except Exception as e:
|
||
return schemas.Msg(code=-9, msg='修改失败', data={'username': data_in})
|
||
return schemas.Msg(code=200, msg='ok')
|
||
|
||
|
||
@router.post("/reset_my_password")
|
||
async def reset_my_password(request: Request,
|
||
data_in: schemas.UserRestMyPassword,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> Any:
|
||
"""
|
||
修改自己的密码
|
||
"""
|
||
await crud.user.reset_password(db,
|
||
schemas.UserRestPassword(user_id=current_user.user_id, password=data_in.password))
|
||
return schemas.Msg(code=200, msg='ok')
|
||
|
||
|
||
@router.post("/add_account")
|
||
async def add_account(
|
||
request: Request,
|
||
data_in: schemas.Createuser,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
创建新账号
|
||
"""
|
||
# user_id = Unionid(data_in.unionid)
|
||
# user_list = get_alluid_list()
|
||
# if user_id not in user_list:
|
||
# return schemas.Msg(code=-9, msg="不是本公司的员工")
|
||
user = get_redis_alluid()
|
||
user_lists = [i['user_id'] for i in user]
|
||
user_list = list(itertools.chain.from_iterable(user_lists))
|
||
a = 0
|
||
for i in user_list:
|
||
if i['name'] == data_in.name:
|
||
user_id = i['userid']
|
||
a += 1
|
||
break
|
||
if a == 1:
|
||
return schemas.Msg(code=-9, msg="不是本公司的员工")
|
||
if is_exists := await crud.user.exists(db, {'user_id': user_id}):
|
||
return schemas.Msg(code=-9, msg='已创建该账号')
|
||
else:
|
||
new_account = schemas.UserCreate(name=data_in.name, hashed_password=get_password_hash('123'),
|
||
unionid=data_in.unionid,
|
||
rank=data_in.rank, email=data_in.email, tel=data_in.tel, user_id=user_id)
|
||
await crud.user.create(db, new_account) # 创建账号
|
||
|
||
return schemas.Msg(code=200, msg='创建成功', data='')
|
||
|
||
|
||
@router.post("/forbid_login")
|
||
async def forbid_login(request: Request,
|
||
data_in: schemas.Get_userid,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.User = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
禁止/解禁用户登录功能
|
||
"""
|
||
if data_in.type == 1:
|
||
await crud.user.forbid_lojin(db, data_in, 1)
|
||
elif data_in.type == 0:
|
||
await crud.user.forbid_lojin(db, data_in, 0)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/owner_list")
|
||
async def owner_list(
|
||
request: Request,
|
||
data_in: schemas.Getdate,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取基本信息列表"""
|
||
try:
|
||
res = await crud.basic_data.one_owner(db, data_in)
|
||
except Exception as e:
|
||
return schemas.Msg(code=-9, msg='查无数据', data='')
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
@router.post("/owner_edit")
|
||
async def owner_edit(
|
||
request: Request,
|
||
data_in: schemas.Ownername,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""新增，删除基本信息"""
|
||
await crud.basic_data.update(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.get("/get_section")
|
||
async def get_section(
|
||
request: Request,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""获取对应部门及职位"""
|
||
res = await crud.section.get_all(db)
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
@router.post("/ins_section")
|
||
async def get_section(
|
||
request: Request,
|
||
data_in: schemas.Ins_section,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""新增对应部门及职位"""
|
||
await crud.section.ins_section(db, data_in)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.get("/api_list")
|
||
async def api_list(
|
||
request: Request,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
所有的api
|
||
"""
|
||
re = await crud.api_module.get_api_module(db)
|
||
res = []
|
||
for i in re:
|
||
if i['path_name'] != 'root':
|
||
i['_id'] = str(i['_id'])
|
||
res.append(i)
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
@router.post("/alter_api_module")
|
||
async def add_policy(
|
||
request: Request,
|
||
data_in: schemas.Add_module,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""修改api_module权限状态"""
|
||
res = await crud.api_module.get_one_module(db, data_in)
|
||
for i in range(len(res['state'])):
|
||
if data_in.url == res['api_list'][i]:
|
||
if data_in.types == False:
|
||
res['state'][i] = False
|
||
else:
|
||
res['state'][i] = True
|
||
await crud.api_module.update_one_module(db, res)
|
||
return schemas.Msg(code=200, msg='修改成功', data='')
|
||
|
||
|
||
@router.get("/api_module")
|
||
async def domain_list(
|
||
request: Request,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
角色管理创建角色时显示的各个模块
|
||
"""
|
||
res = await crud.api_module.get_api_module(db)
|
||
api_module = []
|
||
for i in res:
|
||
if i['path_name'] != 'root':
|
||
data = []
|
||
data.append(i['auth_id'])
|
||
data.append(i['path_name'])
|
||
api_module.append(data)
|
||
return schemas.Msg(code=200, msg='ok', data=api_module)
|
||
|
||
|
||
@router.post("/add_api")
|
||
async def add_api(
|
||
request: Request,
|
||
data_in: schemas.AddApi,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
'在api_module'添加api
|
||
"""
|
||
res = await crud.api_module.get_api_module(db)
|
||
for i in res: # 判断路由是否存在
|
||
if data_in.path in i['api_list']:
|
||
return schemas.Msg(code=200, msg='该路由已存在', data='')
|
||
path_list = []
|
||
for i in res:
|
||
path_list.append(i['path_name'])
|
||
if data_in.name in path_list: # 在原有的基础上添加路由
|
||
for i in res:
|
||
if data_in.name == i['path_name']:
|
||
i['api_list'].append(data_in.path)
|
||
i['api_name'].append(data_in.desc)
|
||
i['state'].append(True)
|
||
await crud.api_module.updata_quanxian_module(db, schemas.Url_module(auth_id=i['auth_id'],
|
||
path_name=data_in.name,
|
||
api_list=i['api_list'],
|
||
api_name=i['api_name'],
|
||
state=i['state']))
|
||
return schemas.Msg(code=200, msg='ok', data='路由添加成功！')
|
||
else: # 另外添加新的权限模块
|
||
auth_list = []
|
||
for i in res:
|
||
auth_list.append(i['auth_id'])
|
||
auth_id = max(auth_list)
|
||
auth_id = 'abc' + str(int(auth_id.split('c')[-1]) + 1)
|
||
await crud.api_module.insert_quanxian(db, schemas.Url_module(auth_id=auth_id, path_name=data_in.name,
|
||
api_list=[data_in.path],
|
||
api_name=[data_in.desc], state=[True]))
|
||
return schemas.Msg(code=200, msg='ok', data='路由添加成功！')
|
||
|
||
|
||
@router.post("/add_policy")
|
||
async def add_policy(
|
||
request: Request,
|
||
data_in: schemas.Datalist,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""
|
||
向当前权限添加新路由
|
||
"""
|
||
res = await crud.url_list.find_one_url(db, data_in)
|
||
for i in range(len(res['api_list'])):
|
||
if res['api_list'][i] == data_in.path:
|
||
res['state'][i] = True
|
||
await crud.url_list.update_url_url(db, res)
|
||
return schemas.Msg(code=200, msg='修改成功', data='')
|
||
|
||
|
||
@router.post("/del_policy")
|
||
async def remove_policy(
|
||
request: Request,
|
||
data_in: schemas.Del_role,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""
|
||
修改角色api权限
|
||
"""
|
||
res = await crud.url_list.find_one_url(db, data_in)
|
||
for i in range(len(res['api_list'])):
|
||
if res['api_list'][i] == data_in.path:
|
||
res['state'][i] = False
|
||
await crud.url_list.update_url_url(db, res)
|
||
return schemas.Msg(code=200, msg='修改成功', data='')
|
||
|
||
|
||
@router.get("/roles")
|
||
async def roles(
|
||
request: Request,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
获取所有的管理员用户
|
||
"""
|
||
res = await crud.url_list.get_all(db)
|
||
role = []
|
||
data = []
|
||
# 区分不同项目下的权限用户
|
||
for i in res:
|
||
if i['system'] == 1 and i['name'] != 'root':
|
||
role.append(i['name'])
|
||
# 得到不同权限用户
|
||
role = list(set(role))
|
||
for id in role:
|
||
data_dcit = {}
|
||
data_dcit['name'] = id
|
||
auth_id = []
|
||
system = []
|
||
data_list = []
|
||
for i in res:
|
||
if i['name'] == id:
|
||
data_one = {}
|
||
auth_id.append(i['auth_id'])
|
||
system.append(i['system'])
|
||
data_one['path_name'] = i['path_name']
|
||
data_one['api_name'] = i['api_name']
|
||
data_one['api_list'] = i['api_list']
|
||
data_one['state'] = i['state']
|
||
data_list.append(data_one)
|
||
data_dcit['datalist'] = data_list
|
||
data_dcit['auth_id'] = auth_id[0]
|
||
data_dcit['system'] = system[0]
|
||
data.append(data_dcit)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/add_roles")
|
||
async def add_roles(
|
||
request: Request,
|
||
data_in: schemas.Add_role,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""
|
||
创建不同权限角色
|
||
"""
|
||
res = await crud.url_list.get_all(db)
|
||
for i in res: # 判断创建的角色是否已经存在
|
||
if data_in.system == 1:
|
||
if data_in.name == i['name']:
|
||
return schemas.Msg(code=200, msg='该角色已存在！')
|
||
else:
|
||
if data_in.name == i['name']:
|
||
return schemas.Msg(code=200, msg='该角色已存在！')
|
||
auth = []
|
||
# 系统默认权限角色
|
||
if data_in.system == 1:
|
||
for i in res:
|
||
auth.append(i['auth_id'])
|
||
max_auth = 'ab' + str(int(max(auth).split('b')[-1]) + 1)
|
||
api_module = await crud.api_module.get_api_module(db)
|
||
for i in api_module:
|
||
if i['auth_id'] in data_in.path_name:
|
||
await crud.url_list.insert_url(db, schemas.Url_list(name=data_in.name, auth_id=max_auth,
|
||
path_name=i['path_name'], api_list=i['api_list'],
|
||
api_name=i['api_name'], state=i['state'],
|
||
system=data_in.system))
|
||
else:
|
||
state = []
|
||
for nu in range(len(i['state'])):
|
||
state.append(False)
|
||
if i['path_name'] != 'root':
|
||
await crud.url_list.insert_url(db, schemas.Url_list(name=data_in.name, auth_id=max_auth,
|
||
path_name=i['path_name'],
|
||
api_list=i['api_list'], api_name=i['api_name'],
|
||
state=state, system=data_in.system))
|
||
return schemas.Msg(code=200, msg='添加角色成功', data='')
|
||
else: # 系统其他权限角色
|
||
for i in res:
|
||
auth.append(i['auth_id'])
|
||
max_auth = 'ab' + str(int(max(auth).split('b')[-1]) + 1)
|
||
api_module = await crud.api_module.get_api_module(db)
|
||
for i in api_module:
|
||
if i['auth_id'] in data_in.path_name:
|
||
await crud.url_list.insert_urls(db, schemas.Url_lists(name=data_in.name, auth_id=max_auth,
|
||
path_name=i['path_name'], api_list=i['api_list'],
|
||
api_name=i['api_name'], state=i['state'],
|
||
system=data_in.system))
|
||
else:
|
||
state = []
|
||
for nu in range(len(i['state'])):
|
||
state.append(False)
|
||
if i['path_name'] != 'root':
|
||
await crud.url_list.insert_urls(db, schemas.Url_lists(name=data_in.name, auth_id=max_auth,
|
||
path_name=i['path_name'],
|
||
api_list=i['api_list'],
|
||
api_name=i['api_name'], state=state,
|
||
system=data_in.system))
|
||
return schemas.Msg(code=200, msg='添加角色成功', data='')
|
||
|
||
|
||
@router.post("/add_role_domain")
|
||
async def add_role_domain(
|
||
request: Request,
|
||
data_in: schemas.AddRoleForUsersInDomain,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
):
|
||
"""
|
||
在当前项目为角色添加相应权限
|
||
"""
|
||
res = await crud.url_list.get_all(db)
|
||
role_id = {}
|
||
for i in res:
|
||
role_id[i['auth_id']] = i['name']
|
||
for item in data_in.data:
|
||
now_quanxian = await crud.user_url.get_quanxian(db, schemas.Url_quanxian(user_id=item.role_id))
|
||
# 如果不存在该用户其他的权限，则新增一个
|
||
if now_quanxian == {}:
|
||
await crud.user_url.insert_quanxian(db, schemas.Url_quanxian(user=item.username,
|
||
user_id=item.role_id,
|
||
quanxian=role_id[item.auth_id],
|
||
quanxian_id=item.auth_id))
|
||
return schemas.Msg(code=200, msg='添加成功', data='')
|
||
# 存在则在这个用户表示已经有权限
|
||
else:
|
||
return schemas.Msg(code=-9, msg='权限已存在', data='')
|
||
|
||
|
||
@router.post("/send_interviewee")
|
||
async def send_interviewee(
|
||
request: Request,
|
||
data_in: schemas.send_in,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""推送给用人经理"""
|
||
sql = f"""
|
||
select job_id,name,job_names from HR.resumes where uid = '{data_in.uid}' limit 1
|
||
"""
|
||
res = await ckdb.execute(sql)
|
||
job_id = res[0]['job_id']
|
||
user = await crud.jobs.find_job(db, job_id)
|
||
user_list = [i['user_id'] for i in user['hr_name']]
|
||
send = f"""【推荐通知】\n{current_user.name}给你推荐了一位面试者\n面试者姓名：{res[0]['name']}\n岗位：{res[0]['job_names']}"""
|
||
send_dates(send, user_list)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/add_interviewee")
|
||
async def add_interviewee(
|
||
request: Request,
|
||
data_in: schemas.add_inter,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
name = await crud.user.get_users(db, data_in.user_id)
|
||
name_list = [i['name'] for i in name]
|
||
interview_name = ','.join(name_list)
|
||
userid = ','.join(data_in.user_id)
|
||
|
||
hr = await crud.user.get_users(db, data_in.hr_user)
|
||
hr_list = [i['name'] for i in hr]
|
||
hr_name = ','.join(hr_list)
|
||
hrid = ','.join(data_in.hr_user)
|
||
sql = f"""
|
||
ALTER TABLE HR.resumes update interview_name = '{interview_name}',interview_id = '{userid}',star_time='{data_in.star_time}',
|
||
end_time='{data_in.end_time}',hr_name='{hr_name}',hr_id='{hrid}',interview_stage=3
|
||
WHERE uid = '{data_in.uid}'
|
||
""" # 添加面试官和hr并自动进入下一阶段
|
||
await ckdb.execute(sql)
|
||
# 同步发送邮件通知被安排了面试
|
||
find_sql = f"""select job_names,name from HR.resumes where uid = '{data_in.uid}' limit 1"""
|
||
df = await ckdb.query_dataframe(find_sql)
|
||
send = f"""【面试通知】\n面试岗位：{df['job_names'][0]}\n面试时间：{data_in.star_time}\n面试者：{df['name'][0]}\nHR：{hr_name}\n面试官：{interview_name}"""
|
||
hr_user = data_in.hr_user
|
||
hr_user.extend(data_in.user_id)
|
||
send_dates(send, hr_user)
|
||
find_sql = f"""
|
||
select uid,name,interview_name,hr_name,star_time,interview_sign,interview_id,job_id,job_names,mail from HR.resumes where uid = '{data_in.uid}'
|
||
"""
|
||
# df = await ckdb.query_dataframe(find_sql)
|
||
df1 = await ckdb.execute(find_sql)
|
||
user_data = df1[0]
|
||
# 存份面试数据到mongodb
|
||
now_time = str(datetime.now()).split('.')[0]
|
||
await crud.interview_record.insert_record(db, {'uid': user_data['uid'], # 唯一id
|
||
'name': user_data['name'], # 求职者姓名
|
||
'interview_name': user_data['interview_name'], # 面试官姓名
|
||
'interview_id': user_data['interview_id'], # 面试官姓名
|
||
'hr_name': user_data['hr_name'], # hr姓名
|
||
'star_time': user_data['star_time'], # 开始面试时间
|
||
'interview_sign': 0, # 签到状态
|
||
'job_id': user_data['job_id'], # 我们自己招聘的职位id
|
||
'job_names': user_data['job_names'], # 我们自己招聘的职位名
|
||
'times': now_time, # 创建数据日期
|
||
'read_status': 0, # 读取状态
|
||
'back_status': 0, # 反馈状态
|
||
'type': 'interview' # 记录的类型
|
||
})
|
||
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
# 头像上传到华为云
|
||
@router.post("/head_to_hw")
|
||
async def head_to_hw(
|
||
request: Request,
|
||
file: UploadFile = File(...),
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 头像上传到华为云 """
|
||
path_data = os.getcwd() + '/head' # 当前文件所在的目录
|
||
if not os.path.exists(path_data):
|
||
os.makedirs(path_data)
|
||
contents = await file.read()
|
||
filename = file.filename
|
||
try:
|
||
with open(path_data + '/' + filename, "wb") as f:
|
||
# 将获取的file文件内容，写入到新文件中
|
||
f.write(contents)
|
||
f.close()
|
||
except:
|
||
return schemas.Msg(code=400, msg='上传文件有误', data=None)
|
||
try:
|
||
# 头像正常上传到华为云
|
||
res = obsClient.putFile('legu-cdn-source', 'hrms/user_icon/' + filename, path_data + '/' + filename)
|
||
if res.status < 300:
|
||
# 地址
|
||
url = res.body.objectUrl
|
||
resData = {'file_url': url, 'filename': 'hrms/user_icon/' + filename}
|
||
return schemas.Msg(code=200, msg='ok', data=resData)
|
||
else:
|
||
# print('errorCode:', res.errorCode)
|
||
# print('errorMessage:', res.errorMessage)
|
||
return schemas.Msg(code=400, msg='上传华为云失败', data=None)
|
||
except:
|
||
import traceback
|
||
print(traceback.format_exc())
|
||
return schemas.Msg(code=400, msg='上传华为云失败', data=None)
|
||
|
||
|
||
# 候选人管理，模糊查询
|
||
@router.post("/find_like")
|
||
async def find_like(
|
||
request: Request,
|
||
data_in: schemas.find_like,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
find_column = ["uid", "age", "gender", "at_school", "name", "event_time", "owner_name", "education",
|
||
"school", "specialty", "interview_name", "mmended_state", "work_list", "work_exp",
|
||
"graduate_time",
|
||
"job_name", "feedback", "interview_round", "interview_state", "interview_stage", "pass_why",
|
||
"pass_text"]
|
||
find_columns = ','.join(find_column)
|
||
if data_in.date != {}:
|
||
strs = []
|
||
for k, v in data_in.date.items():
|
||
if v != '':
|
||
str_s = f"{k} like '%{v}%'"
|
||
strs.append(str_s)
|
||
where = ' and '.join(strs)
|
||
sql = f"""
|
||
select {find_columns} from HR.resumes where interview_stage = '{data_in.interview_stage}' and {where}
|
||
"""
|
||
else:
|
||
sql = f"""
|
||
select {find_columns} from HR.resumes where interview_stage = '{data_in.interview_stage}'
|
||
"""
|
||
data = await ckdb.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=-9, msg='无数据', data='')
|
||
res = chkData(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res)
|
||
|
||
|
||
# 总览
|
||
@router.post("/interview_stage_nu")
|
||
async def interview_stage_nu(
|
||
request: Request,
|
||
data_in: schemas.nterview,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
res_data = {'0': 0, '1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0, '10': 0, '11': 0}
|
||
res = data_in.date
|
||
strs = []
|
||
for k, v in res.items():
|
||
if v != '':
|
||
if 'int' in str(type(v)):
|
||
str_s = f"{k} = {v}"
|
||
strs.append(str_s)
|
||
else:
|
||
if k in ['hr_id', 'interview_id'] and v != '':
|
||
str_s = f"{k} like '%{v}%'"
|
||
else:
|
||
str_s = f"{k} = '{v}'"
|
||
strs.append(str_s)
|
||
where = ' and '.join(strs)
|
||
# 当前日期
|
||
times = get_time()
|
||
len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) == '{times}' and interview_stage = 3"""
|
||
if where == '':
|
||
len_sql = len_sql.replace('where and', 'where', 1)
|
||
# 面试人数
|
||
df_len = await ckdb.query_dataframe(len_sql)
|
||
if df_len.empty:
|
||
len_date = 0
|
||
else:
|
||
len_date = len(df_len)
|
||
res_data['now'] = len_date
|
||
# 1:初筛 2:复筛 3:面试 4:沟通offer 5:待入职 6:放弃入职 7:已入职 8:转正 9:主动离职 10:被动离职 11：淘汰
|
||
sql = """select interview_stage,count(*) as value from HR.resumes group by interview_stage"""
|
||
data = await ckdb.execute(sql)
|
||
for i in data.values():
|
||
key = str(i['interview_stage'])
|
||
if key not in res_data:
|
||
continue
|
||
res_data[key] = i['value']
|
||
# 待发送offer
|
||
off_sql = """select count(*) as value from HR.resumes where offer_state <= 2 and interview_stage = 4"""
|
||
res = await ckdb.execute(off_sql)
|
||
res_data['offer'] = res[0]['value']
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
@router.post("/interview_finds")
|
||
async def interview_find(
|
||
request: Request,
|
||
interview: InterviewDo = Depends(InterviewDo),
|
||
db: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" interview面试数据查询 """
|
||
await interview.init()
|
||
res = interview.find_interview_sql()
|
||
sql = res['sql']
|
||
data = await db.execute(sql)
|
||
if not data:
|
||
return schemas.Msg(code=200, msg='无数据', data=[])
|
||
# 格式化数据
|
||
res_data = len(data)
|
||
return schemas.Msg(code=200, msg='ok', data=res_data)
|
||
|
||
|
||
@router.post("/interview_teacher")
|
||
async def interview_teacher(
|
||
request: Request,
|
||
data_in: schemas.interview_teacher,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 面试反馈 """
|
||
date = json.dumps(data_in.date)
|
||
sql = f"""
|
||
ALTER TABLE HR.resumes update teacher_state = 2,teacher_back={data_in.teacher_back},teacher_txt='{date}'
|
||
WHERE uid = '{data_in.uid}'
|
||
"""
|
||
await ckdb.execute(sql)
|
||
await crud.interview_record.update_back_status(db, data_in.uid, data_in.teacher_back)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/interview")
|
||
async def interview(
|
||
request: Request,
|
||
data_in: schemas.interviews,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 面试情况 """
|
||
res = data_in.date
|
||
strs = []
|
||
for k, v in res.items():
|
||
if v != '':
|
||
if 'int' in str(type(v)):
|
||
str_s = f"{k} = {v}"
|
||
strs.append(str_s)
|
||
else:
|
||
if k in ['hr_id', 'interview_id', 'interview_name', 'hr_name'] and v != '':
|
||
str_s = f"{k} like '%{v}%'"
|
||
else:
|
||
str_s = f"{k} = '{v}'"
|
||
strs.append(str_s)
|
||
where = ' and '.join(strs)
|
||
# 当前日期
|
||
times = get_time()
|
||
# 今天及之后的面试
|
||
len_sql = f"""select count(*) as v from HR.resumes where {where} and toDate(star_time) >= '{times}' and interview_stage = 3"""
|
||
print(len_sql)
|
||
# 已反馈的面试
|
||
sql1 = f"""select count(*) as v from HR.resumes where {where} and teacher_state = 2 and interview_stage = 3"""
|
||
print(sql1)
|
||
# 未反馈的面试
|
||
sql2 = f"""select count(*) as v from HR.resumes where {where} and teacher_state = 1 and interview_stage = 3 """
|
||
print(sql2)
|
||
# 已失效的面试
|
||
sql3 = f"""
|
||
|
||
"""
|
||
if where == '':
|
||
len_sql = len_sql.replace('where and', 'where', 1)
|
||
sql1 = sql1.replace('where and', 'where', 1)
|
||
sql2 = sql2.replace('where and', 'where', 1)
|
||
df_len = await ckdb.execute(len_sql)
|
||
len1 = await ckdb.execute(sql1)
|
||
len2 = await ckdb.execute(sql2)
|
||
len3 = 0
|
||
data = {
|
||
'later': df_len[0]['v'], # 今天及之后的面试
|
||
'teacher_true': len1[0]['v'], # 已反馈的面试
|
||
'later_false': len2[0]['v'], # 未反馈的面试
|
||
'later_invalid': len3 # 已失效的面试
|
||
}
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/interviews")
|
||
async def interviews(
|
||
request: Request,
|
||
data_in: schemas.interviews,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 面试官端详情"""
|
||
res = data_in.date
|
||
strs = []
|
||
for k, v in res.items():
|
||
if v != '':
|
||
if 'int' in str(type(v)):
|
||
str_s = f"{k} = {v}"
|
||
strs.append(str_s)
|
||
else:
|
||
if k in ['hr_id', 'interview_id', 'interview_name', 'hr_name'] and v != '':
|
||
str_s = f"{k} like '%{v}%'"
|
||
else:
|
||
str_s = f"{k} = '{v}'"
|
||
strs.append(str_s)
|
||
where = ' and '.join(strs)
|
||
# 当前日期
|
||
times = get_time()
|
||
# 今天及之后的面试
|
||
sql = f"""select uid,name,job_names,end_time,star_time,interview_type,hr_name,interview_stage,teacher_back from HR.resumes
|
||
where {where} and toDate(star_time) >= '{times}' and interview_stage = 3"""
|
||
print(sql)
|
||
# 已反馈的面试
|
||
sql1 = f"""select uid,name,job_names,end_time,star_time,interview_type,hr_name,interview_stage,teacher_back from HR.resumes
|
||
where {where} and teacher_state = 2 and interview_stage = 3"""
|
||
print(sql1)
|
||
# 未反馈的面试
|
||
sql2 = f"""select uid,name,job_names,end_time,star_time,interview_type,hr_name,interview_stage,teacher_back from HR.resumes
|
||
where {where} and teacher_state = 1 and interview_stage = 3 """
|
||
print(sql2)
|
||
# 已失效的面试
|
||
sql3 = f"""
|
||
|
||
"""
|
||
if where == '':
|
||
sql = sql.replace('where and', 'where', 1)
|
||
sql1 = sql1.replace('where and', 'where', 1)
|
||
sql2 = sql2.replace('where and', 'where', 1)
|
||
|
||
data = await ckdb.execute(sql)
|
||
res = chkData(data)
|
||
data1 = await ckdb.execute(sql1)
|
||
res1 = chkData(data1)
|
||
data2 = await ckdb.execute(sql2)
|
||
res2 = chkData(data2)
|
||
res3 = []
|
||
datas = {'later': res, # 今天及之后的面试
|
||
'teacher_true': res1, # 已反馈的面试
|
||
'later_false': res2, # 未反馈的面试
|
||
'later_invalid': res3} # 已失效的面试
|
||
|
||
return schemas.Msg(code=200, msg='ok', data=datas)
|
||
|
||
|
||
@router.post("/up_teacher")
|
||
async def interview_teacher(
|
||
request: Request,
|
||
data_in: schemas.interview_teacher,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 修改面试反馈 """
|
||
date = json.dumps(data_in.date)
|
||
sql = f"""
|
||
ALTER TABLE HR.resumes update teacher_back={data_in.teacher_back},teacher_txt='{date}'
|
||
WHERE uid = '{data_in.uid}'
|
||
"""
|
||
print(sql)
|
||
await ckdb.execute(sql)
|
||
return schemas.Msg(code=200, msg='ok', data='')
|
||
|
||
|
||
@router.post("/get_teacher")
|
||
async def interview_teacher(
|
||
request: Request,
|
||
data_in: schemas.get_teacher,
|
||
ckdb: CKDrive = Depends(get_ck_db),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
""" 获取面试反馈 """
|
||
sql = f"""select uid,teacher_back,teacher_txt from HR.resumes WHERE uid = '{data_in.uid}' limit 1"""
|
||
print(sql)
|
||
res = await ckdb.execute(sql)
|
||
data = chkData(res)
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|
||
|
||
|
||
@router.post("/record")
|
||
async def hint(
|
||
request: Request,
|
||
data_in: schemas.record,
|
||
db: AsyncIOMotorDatabase = Depends(get_database),
|
||
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
||
) -> schemas.Msg:
|
||
"""个人面试记录"""
|
||
res = []
|
||
interview = await crud.interview_record.all_fields(db, {'uid': data_in.uid})
|
||
for i in interview:
|
||
i.pop('_id')
|
||
res.append(i)
|
||
data = sorted(res, key=operator.itemgetter('times'))
|
||
return schemas.Msg(code=200, msg='ok', data=data)
|