2141 lines
70 KiB
Python
2141 lines
70 KiB
Python
import operator
|
|
import os
|
|
import re
|
|
import pandas as pd
|
|
from copy import deepcopy
|
|
from fastapi import APIRouter, Depends, Request, File, UploadFile
|
|
from motor.motor_asyncio import AsyncIOMotorDatabase
|
|
|
|
from api import deps
|
|
from utils.dingding import get_redis_alluid, send_dates
|
|
from utils.jianli import get_resume
|
|
from utils.func import get_every_days, get_every_weeks, get_every_months
|
|
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 models.interview_zsgc import InterviewDo
|
|
from utils import get_time, qujian_time, Download_xlsx, send_str_mail
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
# 候选人质量报表
|
|
@router.post("/man_mass_form")
|
|
async def man_mass_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
db: CKDrive = Depends(get_ck_db),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await db.execute(sql)
|
|
school_985 = ['清华大学', '北京大学', '中国人民大学', '北京理工大学', '北京航空航天大学', '中央民族大学', '北京师范大学',
|
|
'中国农业大学', '天津大学', '南开大学', '复旦大学', '上海交通大学', '同济大学', '华东师范大学', '重庆大学', '四川大学',
|
|
'电子科技大学', '湖南大学', '国防科技大学', '中南大学', '厦门大学']
|
|
|
|
school_211 = ['上海外国语大学', '东华大学', '上海财经大学', '华东理工大学', '上海大学', '天津医科大学', '吉林大学', '东北师范大学',
|
|
'延边大学', '哈尔滨工业大学', '哈尔滨工程大学', '东北农业大学', '东北林业大学', '南京大学', '东南大学', '苏州大学',
|
|
'中国矿业大学', '中国药科大学', '河海大学', '南京航空航天大学', '江南大学', '南京农业大学', '南京理工大学', '浙江大学',
|
|
'中国科技大学', '安徽大学', '合肥工业大学', '福州大学', '南昌大学', '山东大学', '中国海洋大学', '石油大学',
|
|
'湖南师范大学', '广西大学', '中山大学', '暨南大学', '华南理工大学', '华南师范大学', '广州中医药大学', '武汉大学',
|
|
'华中科技大学', '中国地质大学', '武汉理工大学', '华中师范大学', '华中农业大学', '中南财经政法大学']
|
|
# 性别
|
|
gander = {
|
|
'男': [],
|
|
'女': []
|
|
}
|
|
# 年龄
|
|
age = {
|
|
'20-29': [],
|
|
'30-39': [],
|
|
'40-49': [],
|
|
'50-59': [],
|
|
'60-100': [],
|
|
}
|
|
# 学历
|
|
education = {
|
|
'大专': [],
|
|
'本科': [],
|
|
'研究生': [],
|
|
'博士': [],
|
|
'硕士': []
|
|
}
|
|
# 工作经验
|
|
work_exp = {
|
|
'0-2': [],
|
|
'3-6': [],
|
|
'6-10': [],
|
|
'10-20': [],
|
|
'20-40': []
|
|
}
|
|
# 所在地
|
|
account = {
|
|
}
|
|
# 毕业院校
|
|
school = {
|
|
}
|
|
# 就职公司
|
|
work_for = {
|
|
}
|
|
# 渠道
|
|
owner_name = {
|
|
'前程无忧': [],
|
|
'人才库': [],
|
|
'智联招聘': [],
|
|
'Boss直聘': [],
|
|
'58同城': []
|
|
}
|
|
# 职位
|
|
job_name = {
|
|
}
|
|
# 学校类型
|
|
school_type = {
|
|
'985': [],
|
|
'211': [],
|
|
'其他': [],
|
|
}
|
|
if not data:
|
|
return schemas.Msg(code=200, msg='无数据', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
|
|
i_gander = interview_data.get('gander', '男')
|
|
if i_gander == '男':
|
|
gander['男'].append(i_name)
|
|
else:
|
|
gander['女'].append(i_name)
|
|
|
|
i_age = interview_data.get('age', 20)
|
|
if i_age <= 29:
|
|
age['20-29'].append(i_name)
|
|
elif 30 <= i_age <= 39:
|
|
age['30-39'].append(i_name)
|
|
elif 40 <= i_age <= 49:
|
|
age['40-49'].append(i_name)
|
|
elif 50 <= i_age <= 59:
|
|
age['50-59'].append(i_name)
|
|
else:
|
|
age['60-100'].append(i_name)
|
|
|
|
i_education = interview_data.get('education', 1)
|
|
if i_education == 1:
|
|
education['大专'].append(i_name)
|
|
elif i_education == 2:
|
|
education['本科'].append(i_name)
|
|
elif i_education == 3:
|
|
education['研究生'].append(i_name)
|
|
elif i_education == 4:
|
|
education['博士'].append(i_name)
|
|
else:
|
|
education['硕士'].append(i_name)
|
|
|
|
i_owner_name = interview_data.get('owner_name', 2)
|
|
if i_owner_name == 1:
|
|
owner_name['前程无忧'].append(i_name)
|
|
elif i_owner_name == 2:
|
|
owner_name['人才库'].append(i_name)
|
|
elif i_owner_name == 3:
|
|
owner_name['智联招聘'].append(i_name)
|
|
elif i_owner_name == 4:
|
|
owner_name['Boss直聘'].append(i_name)
|
|
else:
|
|
owner_name['58同城'].append(i_name)
|
|
|
|
i_school = interview_data.get('school', '')
|
|
if i_school:
|
|
if i_school in school:
|
|
school[i_school].append(i_name)
|
|
else:
|
|
school[i_school] = [i_name]
|
|
if i_school in school_985:
|
|
school_type['985'].append(i_name)
|
|
school_type['211'].append(i_name)
|
|
elif i_school in school_211:
|
|
school_type['211'].append(i_name)
|
|
else:
|
|
school_type['其他'].append(i_name)
|
|
|
|
i_work_exp = interview_data.get('work_exp', 1)
|
|
if i_work_exp <= 2:
|
|
work_exp['0-2'].append(i_name)
|
|
elif 3 <= i_work_exp < 6:
|
|
work_exp['3-6'].append(i_name)
|
|
elif 6 <= i_work_exp < 10:
|
|
work_exp['6-10'].append(i_name)
|
|
elif 10 <= i_work_exp < 20:
|
|
work_exp['10-20'].append(i_name)
|
|
else:
|
|
work_exp['20-40'].append(i_name)
|
|
|
|
i_job_name = interview_data.get('job_names', '')
|
|
if i_job_name:
|
|
if i_job_name in job_name:
|
|
job_name[i_job_name].append(i_name)
|
|
else:
|
|
job_name[i_job_name] = [i_name]
|
|
|
|
i_account = interview_data.get('account', '')
|
|
if i_account:
|
|
if i_account in account:
|
|
account[i_account].append(i_name)
|
|
else:
|
|
account[i_account] = [i_name]
|
|
|
|
i_work_list = interview_data.get('work_list', '')
|
|
if i_work_list:
|
|
data_work = eval(i_work_list[0])
|
|
i_work_for = data_work.get('name', '')
|
|
if i_work_for:
|
|
if i_work_for in work_for:
|
|
work_for[i_work_for].append(i_name)
|
|
else:
|
|
work_for[i_work_for] = [i_name]
|
|
|
|
res_msg = {
|
|
'gander': gander,
|
|
'age': age,
|
|
'education': education,
|
|
'work_exp': work_exp,
|
|
'account': account,
|
|
'school': school,
|
|
'work_for': work_for,
|
|
'owner_name': owner_name,
|
|
'job_name': job_name,
|
|
'school_type': school_type
|
|
}
|
|
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量性别报表
|
|
@router.post("/man_gander_form")
|
|
async def man_gander_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量性别报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 性别
|
|
gander = {
|
|
'男': [],
|
|
'女': []
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_gander = interview_data.get('gander', '男')
|
|
if i_gander == '男':
|
|
gander['男'].append(i_name)
|
|
else:
|
|
gander['女'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': gander,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量年龄报表
|
|
@router.post("/man_age_form")
|
|
async def man_age_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量年龄报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 年龄
|
|
age = {
|
|
'20-29': [],
|
|
'30-39': [],
|
|
'40-49': [],
|
|
'50-59': [],
|
|
'60-100': [],
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_age = interview_data.get('age', 20)
|
|
if i_age <= 29:
|
|
age['20-29'].append(i_name)
|
|
elif 30 <= i_age <= 39:
|
|
age['30-39'].append(i_name)
|
|
elif 40 <= i_age <= 49:
|
|
age['40-49'].append(i_name)
|
|
elif 50 <= i_age <= 59:
|
|
age['50-59'].append(i_name)
|
|
else:
|
|
age['60-100'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': age,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量学历报表
|
|
@router.post("/man_education_form")
|
|
async def man_education_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量学历报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 学历
|
|
education = {
|
|
'大专': [],
|
|
'本科': [],
|
|
'研究生': [],
|
|
'博士': [],
|
|
'硕士': []
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_education = interview_data.get('education', 1)
|
|
if i_education == 1:
|
|
education['大专'].append(i_name)
|
|
elif i_education == 2:
|
|
education['本科'].append(i_name)
|
|
elif i_education == 3:
|
|
education['研究生'].append(i_name)
|
|
elif i_education == 4:
|
|
education['博士'].append(i_name)
|
|
else:
|
|
education['硕士'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': education,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量工作经验报表
|
|
@router.post("/man_work_exp_form")
|
|
async def man_work_exp_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量工作经验报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 工作经验
|
|
work_exp = {
|
|
'0-2': [],
|
|
'3-6': [],
|
|
'6-10': [],
|
|
'10-20': [],
|
|
'20-40': []
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_work_exp = interview_data.get('work_exp', 1)
|
|
if i_work_exp <= 2:
|
|
work_exp['0-2'].append(i_name)
|
|
elif 3 <= i_work_exp < 6:
|
|
work_exp['3-6'].append(i_name)
|
|
elif 6 <= i_work_exp < 10:
|
|
work_exp['6-10'].append(i_name)
|
|
elif 10 <= i_work_exp < 20:
|
|
work_exp['10-20'].append(i_name)
|
|
else:
|
|
work_exp['20-40'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': work_exp,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量所在地报表
|
|
@router.post("/man_account_form")
|
|
async def man_account_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量所在地报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 所在地
|
|
account = {
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_account = interview_data.get('account', '')
|
|
if i_account:
|
|
if i_account in account:
|
|
account[i_account].append(i_name)
|
|
else:
|
|
account[i_account] = [i_name]
|
|
|
|
res_msg = {
|
|
'data': account,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量毕业院校报表
|
|
@router.post("/man_school_form")
|
|
async def man_school_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量毕业院校报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 毕业院校
|
|
school = {
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_school = interview_data.get('school', '')
|
|
if i_school:
|
|
if i_school in school:
|
|
school[i_school].append(i_name)
|
|
else:
|
|
school[i_school] = [i_name]
|
|
|
|
res_msg = {
|
|
'data': school,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量就职公司报表
|
|
@router.post("/man_work_for_form")
|
|
async def man_work_for_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量就职公司报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 就职公司
|
|
work_for = {
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_work_list = interview_data.get('work_list', '')
|
|
if i_work_list:
|
|
data_work = eval(i_work_list[0])
|
|
i_work_for = data_work.get('name', '')
|
|
if i_work_for:
|
|
if i_work_for in work_for:
|
|
work_for[i_work_for].append(i_name)
|
|
else:
|
|
work_for[i_work_for] = [i_name]
|
|
|
|
res_msg = {
|
|
'data': work_for,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量渠道报表
|
|
@router.post("/man_owner_name_form")
|
|
async def man_owner_name_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量渠道报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
# 渠道
|
|
owner_name = {
|
|
'前程无忧': [],
|
|
'人才库': [],
|
|
'智联招聘': [],
|
|
'Boss直聘': [],
|
|
'58同城': []
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_owner_name = interview_data.get('owner_name', 2)
|
|
if i_owner_name == 1:
|
|
owner_name['前程无忧'].append(i_name)
|
|
elif i_owner_name == 2:
|
|
owner_name['人才库'].append(i_name)
|
|
elif i_owner_name == 3:
|
|
owner_name['智联招聘'].append(i_name)
|
|
elif i_owner_name == 4:
|
|
owner_name['Boss直聘'].append(i_name)
|
|
else:
|
|
owner_name['58同城'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': owner_name,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量职位报表
|
|
@router.post("/man_job_name_form")
|
|
async def man_job_name_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量职位报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 职位
|
|
job_name = {
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_job_name = interview_data.get('job_names', '')
|
|
if i_job_name:
|
|
if i_job_name in job_name:
|
|
job_name[i_job_name].append(i_name)
|
|
else:
|
|
job_name[i_job_name] = [i_name]
|
|
|
|
res_msg = {
|
|
'data': job_name,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人质量学校类型报表
|
|
@router.post("/man_school_type_form")
|
|
async def man_school_type_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人质量学校类型报表 """
|
|
await interview.init()
|
|
res = interview.get_man_mass_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
school_985 = ['清华大学', '北京大学', '中国人民大学', '北京理工大学', '北京航空航天大学', '中央民族大学', '北京师范大学',
|
|
'中国农业大学', '天津大学', '南开大学', '复旦大学', '上海交通大学', '同济大学', '华东师范大学', '重庆大学', '四川大学',
|
|
'电子科技大学', '湖南大学', '国防科技大学', '中南大学', '厦门大学']
|
|
|
|
school_211 = ['上海外国语大学', '东华大学', '上海财经大学', '华东理工大学', '上海大学', '天津医科大学', '吉林大学', '东北师范大学',
|
|
'延边大学', '哈尔滨工业大学', '哈尔滨工程大学', '东北农业大学', '东北林业大学', '南京大学', '东南大学', '苏州大学',
|
|
'中国矿业大学', '中国药科大学', '河海大学', '南京航空航天大学', '江南大学', '南京农业大学', '南京理工大学', '浙江大学',
|
|
'中国科技大学', '安徽大学', '合肥工业大学', '福州大学', '南昌大学', '山东大学', '中国海洋大学', '石油大学',
|
|
'湖南师范大学', '广西大学', '中山大学', '暨南大学', '华南理工大学', '华南师范大学', '广州中医药大学', '武汉大学',
|
|
'华中科技大学', '中国地质大学', '武汉理工大学', '华中师范大学', '华中农业大学', '中南财经政法大学']
|
|
# 学校类型
|
|
school_type = {
|
|
'985': [],
|
|
'211': [],
|
|
'其他': [],
|
|
}
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 处理数据
|
|
for interview_data in data.values():
|
|
i_name = interview_data.get('name', '默认名字')
|
|
i_school = interview_data.get('school', '')
|
|
if i_school:
|
|
if i_school in school_985:
|
|
school_type['985'].append(i_name)
|
|
school_type['211'].append(i_name)
|
|
elif i_school in school_211:
|
|
school_type['211'].append(i_name)
|
|
else:
|
|
school_type['其他'].append(i_name)
|
|
|
|
res_msg = {
|
|
'data': school_type,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 候选人明细报表
|
|
@router.post("/man_info_form")
|
|
async def man_info_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 候选人明细报表 """
|
|
await interview.init()
|
|
res = interview.get_man_info_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
for key, interview_data in data.items():
|
|
i_work_list = interview_data.get('work_list', '')
|
|
if i_work_list:
|
|
data_work = eval(i_work_list[0])
|
|
i_work_for = data_work.get('name', '')
|
|
if i_work_for:
|
|
data[key]['work_for'] = i_work_for
|
|
continue
|
|
data[key]['work_for'] = ''
|
|
new_data = [v for k, v in data.items()]
|
|
res_data = []
|
|
for data in new_data:
|
|
age = data['age']
|
|
education = data['education']
|
|
work_exp = data['work_exp']
|
|
if age:
|
|
data['age'] = str(age) + '岁'
|
|
else:
|
|
data['age'] = '20岁'
|
|
if education:
|
|
data['education'] = education_dict.get(education, '大专')
|
|
if work_exp:
|
|
data['work_exp'] = str(int(work_exp)) + '年'
|
|
else:
|
|
data['work_exp'] = '一年以内'
|
|
|
|
new_res = {k: v for k, v in data.items() if k != 'work_list'}
|
|
res_data.append(new_res)
|
|
level_list = {
|
|
"uid": "用户id",
|
|
"age": "年龄",
|
|
"gender": "性别",
|
|
"name": "姓名",
|
|
"education": "学历",
|
|
"school": "毕业院校",
|
|
"work_exp": "工作经验",
|
|
"job_name": "应聘职位",
|
|
"account": "所属地",
|
|
"graduate_time": "毕业时间",
|
|
"phone": "电话",
|
|
"work_for": "上家公司"
|
|
}
|
|
res_true_data = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_msg = {
|
|
'data': res_true_data,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_msg)
|
|
|
|
|
|
# 职位阶段数据报表
|
|
@router.post("/every_stage_form")
|
|
async def every_stage_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 职位阶段数据报表 """
|
|
all_jobs = await crud.jobs.all_some_field(db)
|
|
res_msg = {}
|
|
job_id_to_name = {}
|
|
job_ids = []
|
|
for job_data in all_jobs:
|
|
job_id = job_data['job_id']
|
|
job_ids.append(job_id)
|
|
job_name = job_data['job_name']
|
|
job_id_to_name[job_id] = job_name
|
|
res_job_data = deepcopy({k: v for k, v in job_data.items() if k != 'job_id'})
|
|
res_job_data.update({
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_in_num': job_data['now_job_num'],
|
|
})
|
|
res_job_data['principal'] = res_job_data['principal'][0]['name']
|
|
res_msg[job_name] = res_job_data
|
|
|
|
await interview.init()
|
|
res = interview.get_every_stage_form_sql(job_ids)
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
for ck_data in data.values():
|
|
# 职位id不存在跳过
|
|
if ck_data['job_id'] not in job_id_to_name:
|
|
continue
|
|
ck_job_name = job_id_to_name[ck_data['job_id']]
|
|
stage = ck_data['interview_stage']
|
|
if stage == 1:
|
|
res_msg[ck_job_name]['start_num'] += 1
|
|
elif stage == 2:
|
|
res_msg[ck_job_name]['screen_num'] += 1
|
|
elif stage == 3:
|
|
res_msg[ck_job_name]['exam_num'] += 1
|
|
elif stage == 4:
|
|
res_msg[ck_job_name]['offer_num'] += 1
|
|
elif stage == 5:
|
|
res_msg[ck_job_name]['wait_work_num'] += 1
|
|
|
|
res_data = []
|
|
for k, v in res_msg.items():
|
|
res_value = deepcopy(v)
|
|
res_data.append(res_value)
|
|
level_list = {
|
|
"job_name": "职位",
|
|
"job_sector": "部门",
|
|
"principal": "负责人",
|
|
"start_time": "招聘开始时间",
|
|
"job_num": "招聘人数",
|
|
"start_num": "初筛",
|
|
"screen_num": "复筛",
|
|
"exam_num": "面试",
|
|
"offer_num": "offer",
|
|
"wait_work_num": "待入职",
|
|
"work_in_num": "已入职"
|
|
}
|
|
res_true_data = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_back_data = {
|
|
'data': res_true_data,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_back_data)
|
|
|
|
|
|
# hr工作量报表
|
|
@router.post("/hr_works_form")
|
|
async def hr_works_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" hr工作量报表 """
|
|
await interview.init()
|
|
res = interview.get_hr_works_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
res_msg = {}
|
|
job_name_sector = {}
|
|
hr_names = [] # 查询面试数据
|
|
job_ids = []
|
|
for ck_data in data.values():
|
|
ck_job_id = ck_data['job_id']
|
|
hr_name = ck_data['hr_name']
|
|
|
|
if hr_name not in hr_names:
|
|
hr_names.append(hr_name)
|
|
|
|
job_data = await crud.jobs.find_job_name(db, ck_job_id)
|
|
if not job_data:
|
|
continue
|
|
job_name = job_data['job_name'] # 职位
|
|
job_sector = job_data['job_sector'] # 部门
|
|
job_name_sector.update({
|
|
job_name: job_sector
|
|
})
|
|
|
|
# 未录入职位
|
|
if ck_job_id not in job_ids:
|
|
job_ids.append(ck_job_id)
|
|
res_msg[job_name] = {hr_name: {
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'exam_set_num': 0,
|
|
'exam_ok_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_num': 0
|
|
}}
|
|
# 已录入职位
|
|
else:
|
|
if hr_name not in res_msg[job_name]:
|
|
res_msg[job_name][hr_name] = {
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'exam_set_num': 0,
|
|
'exam_ok_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_num': 0
|
|
}
|
|
|
|
stage = ck_data['interview_stage']
|
|
if stage >= 1:
|
|
res_msg[job_name][hr_name]['start_num'] += 1
|
|
if stage >= 2:
|
|
res_msg[job_name][hr_name]['screen_num'] += 1
|
|
if stage >= 3:
|
|
res_msg[job_name][hr_name]['exam_num'] += 1
|
|
if stage >= 4:
|
|
res_msg[job_name][hr_name]['offer_num'] += 1
|
|
if stage >= 5:
|
|
res_msg[job_name][hr_name]['wait_work_num'] += 1
|
|
if stage >= 7:
|
|
res_msg[job_name][hr_name]['work_num'] += 1
|
|
interview_records = await crud.interview_record.find_job_some(db, hr_names)
|
|
for record in interview_records:
|
|
record_job_name = record['job_names']
|
|
record_hr_name = record['hr_name']
|
|
record_interview_sign = record['interview_sign']
|
|
if record_job_name in res_msg:
|
|
if record_hr_name not in res_msg[record_job_name]:
|
|
res_msg[record_job_name][record_hr_name] = {
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'exam_set_num': 0,
|
|
'exam_ok_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_num': 0
|
|
}
|
|
res_msg[record_job_name][record_hr_name]['exam_set_num'] += 1
|
|
if record_interview_sign:
|
|
res_msg[record_job_name][record_hr_name]['exam_ok_num'] += 1
|
|
for job_name1, msg_data in res_msg.items():
|
|
count_data = {
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'exam_set_num': 0,
|
|
'exam_ok_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_num': 0
|
|
}
|
|
for key, value_data in msg_data.items():
|
|
for true_key, num in value_data.items():
|
|
count_data[true_key] += num
|
|
res_msg[job_name1].update({'总计': count_data})
|
|
|
|
res_data = {}
|
|
for k, v in res_msg.items():
|
|
if k in job_name_sector:
|
|
if job_name_sector[k] not in res_data:
|
|
res_data[job_name_sector[k]] = {k: v}
|
|
else:
|
|
res_data[job_name_sector[k]].update({k: v})
|
|
else:
|
|
if '其他' in res_data:
|
|
res_data['其他'] = {k: v}
|
|
else:
|
|
res_data['其他'].update({k: v})
|
|
res_data1 = []
|
|
for k, v in res_data.items():
|
|
data1 = {'date_name': k}
|
|
for k1, v1 in v.items():
|
|
data2 = {'job_name': k1}
|
|
for k2, v2 in v1.items():
|
|
v2.update(data1)
|
|
v2.update(data2)
|
|
v2.update({'name': k2})
|
|
true_data = deepcopy(v2)
|
|
res_data1.append(true_data)
|
|
level_list = {
|
|
"date_name": "部门",
|
|
"job_name": "职位",
|
|
"name": "HR",
|
|
"start_num": "初筛",
|
|
"screen_num": "复筛",
|
|
"exam_num": "面试",
|
|
"exam_set_num": "创建面试",
|
|
"exam_ok_num": "面试签到",
|
|
"offer_num": "offer",
|
|
"wait_work_num": "待入职",
|
|
"work_num": "已入职"
|
|
}
|
|
res_true_msg = {
|
|
'data': res_data1,
|
|
'level_list': level_list,
|
|
}
|
|
res_true_data = {
|
|
'data': res_true_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_true_data)
|
|
|
|
|
|
# 职位阶段通过率报表
|
|
@router.post("/stage_success_form")
|
|
async def stage_success_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 职位阶段通过率报表 """
|
|
all_jobs = await crud.jobs.all_some_field(db)
|
|
res_msg = {}
|
|
job_id_to_name = {}
|
|
job_ids = []
|
|
for job_data in all_jobs:
|
|
job_id = job_data['job_id']
|
|
job_ids.append(job_id)
|
|
job_name = job_data['job_name']
|
|
job_id_to_name[job_id] = job_name
|
|
res_job_data = deepcopy({k: v for k, v in job_data.items() if k not in ['job_id', 'now_job_num']})
|
|
res_job_data.update({
|
|
'start_num': 0,
|
|
'screen_num': 0,
|
|
'exam_num': 0,
|
|
'offer_num': 0,
|
|
'wait_work_num': 0,
|
|
'work_in_num': 0
|
|
})
|
|
res_job_data['principal'] = res_job_data['principal'][0]['name']
|
|
res_msg[job_name] = res_job_data
|
|
|
|
await interview.init()
|
|
res = interview.get_every_stage_form_sql(job_ids)
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
for ck_data in data.values():
|
|
# 职位id不存在跳过
|
|
if ck_data['job_id'] not in job_id_to_name:
|
|
continue
|
|
ck_job_name = job_id_to_name[ck_data['job_id']]
|
|
stage = ck_data['interview_stage']
|
|
if stage >= 1:
|
|
res_msg[ck_job_name]['start_num'] += 1
|
|
if stage >= 2:
|
|
res_msg[ck_job_name]['screen_num'] += 1
|
|
if stage >= 3:
|
|
res_msg[ck_job_name]['exam_num'] += 1
|
|
if stage >= 4:
|
|
res_msg[ck_job_name]['offer_num'] += 1
|
|
if stage >= 5:
|
|
res_msg[ck_job_name]['wait_work_num'] += 1
|
|
if stage >= 7:
|
|
res_msg[ck_job_name]['work_in_num'] += 1
|
|
|
|
for res_name, res_data in res_msg.items():
|
|
chk_num1 = res_data['start_num']
|
|
chk_num2 = res_data['screen_num']
|
|
chk_num3 = res_data['exam_num']
|
|
chk_num4 = res_data['offer_num']
|
|
chk_num5 = res_data['wait_work_num']
|
|
chk_num7 = res_data['work_in_num']
|
|
if chk_num1 and chk_num2:
|
|
chance_1 = round(chk_num2 / chk_num1, 2)
|
|
else:
|
|
chance_1 = 0
|
|
if chk_num2 and chk_num3:
|
|
chance_2 = round(chk_num3 / chk_num2, 2)
|
|
else:
|
|
chance_2 = 0
|
|
if chk_num3 and chk_num4:
|
|
chance_3 = round(chk_num4 / chk_num3, 2)
|
|
else:
|
|
chance_3 = 0
|
|
if chk_num4 and chk_num5:
|
|
chance_4 = round(chk_num5 / chk_num4, 2)
|
|
else:
|
|
chance_4 = 0
|
|
if chk_num5 and chk_num7:
|
|
chance_5 = round(chk_num7 / chk_num5, 2)
|
|
else:
|
|
chance_5 = 0
|
|
res_msg[res_name].update({
|
|
'chance_1': chance_1,
|
|
'chance_2': chance_2,
|
|
'chance_3': chance_3,
|
|
'chance_4': chance_4,
|
|
'chance_5': chance_5
|
|
})
|
|
res_data1 = []
|
|
for k, v in res_msg.items():
|
|
res_value = deepcopy(v)
|
|
res_data1.append(res_value)
|
|
level_list = {
|
|
"job_name": "职位",
|
|
"job_sector": "部门",
|
|
"principal": "负责人",
|
|
"start_time": "招聘开始时间",
|
|
"job_num": "招聘人数",
|
|
"start_num": "初筛",
|
|
"screen_num": "复筛",
|
|
"exam_num": "面试",
|
|
"offer_num": "offer",
|
|
"wait_work_num": "待入职",
|
|
"work_in_num": "已入职",
|
|
"chance_1": "初筛通过率",
|
|
"chance_2": "复筛通过率",
|
|
"chance_3": "面试通过率",
|
|
"chance_4": "offer通过率",
|
|
"chance_5": "待入职通过率"
|
|
}
|
|
res_true_data = {
|
|
'data': res_data1,
|
|
'level_list': level_list
|
|
}
|
|
res_back_data = {
|
|
'data': res_true_data,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_back_data)
|
|
|
|
|
|
# 招聘漏斗报表
|
|
@router.post("/interview_funnel_form")
|
|
async def interview_funnel_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 招聘漏斗报表 """
|
|
await interview.init()
|
|
res = interview.get_hr_works_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
res_msg = {
|
|
'初筛': 0,
|
|
'复筛': 0,
|
|
'面试': 0,
|
|
'offer': 0,
|
|
'待入职': 0,
|
|
'已入职': 0
|
|
}
|
|
for i_data in data.values():
|
|
stage = i_data['interview_stage']
|
|
if stage >= 1:
|
|
res_msg['初筛'] += 1
|
|
if stage >= 2:
|
|
res_msg['复筛'] += 1
|
|
if stage >= 3:
|
|
res_msg['面试'] += 1
|
|
if stage >= 4:
|
|
res_msg['offer'] += 1
|
|
if stage >= 5:
|
|
res_msg['待入职'] += 1
|
|
if stage >= 7:
|
|
res_msg['已入职'] += 1
|
|
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 初筛数量
|
|
@router.post("/interview_start_form")
|
|
async def interview_start_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 初筛 """
|
|
await interview.init()
|
|
res = interview.get_hr_works_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
res_msg = {
|
|
'value': 0,
|
|
}
|
|
for i_data in data.values():
|
|
stage = i_data['interview_stage']
|
|
if stage >= 1:
|
|
res_msg['value'] += 1
|
|
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 面试数量
|
|
@router.post("/interview_exam_form")
|
|
async def interview_exam_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 安排面试总次数 """
|
|
await interview.init()
|
|
res = interview.get_hr_works_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
res_msg = {
|
|
'value': 0,
|
|
}
|
|
for i_data in data.values():
|
|
stage = i_data['interview_stage']
|
|
if stage >= 3:
|
|
res_msg['value'] += 1
|
|
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 待入职数量
|
|
@router.post("/interview_wait_in_form")
|
|
async def interview_wait_in_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 待入职 """
|
|
await interview.init()
|
|
res = interview.get_hr_works_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
res_msg = {
|
|
'value': 0,
|
|
}
|
|
for i_data in data.values():
|
|
stage = i_data['interview_stage']
|
|
if stage >= 5:
|
|
res_msg['value'] += 1
|
|
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 初筛渠道
|
|
@router.post("/interview_stage1_owner_form")
|
|
async def interview_stage1_owner_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 初筛阶段渠道 """
|
|
await interview.init()
|
|
res = interview.get_owner_stage1_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 简历渠道
|
|
owner_dict = {1: '前程无忧', 2: '人才库', 3: '智联招聘', 4: 'Boss直聘', 5: '58同城', 6: '拉勾'}
|
|
chk_data = {
|
|
'前程无忧': [],
|
|
'人才库': [],
|
|
'智联招聘': [],
|
|
'Boss直聘': [],
|
|
'58同城': [],
|
|
'拉勾': []
|
|
}
|
|
for i in data.values():
|
|
owner_name = owner_dict[i['owner_name']]
|
|
i_data = deepcopy(i)
|
|
chk_data[owner_name].append(i_data)
|
|
res_data = {
|
|
'data': chk_data,
|
|
'table_data': table_data,
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 招聘职位数
|
|
@router.post("/interview_job_num_form")
|
|
async def interview_job_num_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 开放中的职位 """
|
|
job_data = await crud.jobs.all_some_field(db)
|
|
value = list(set([i['job_name'] for i in job_data]))
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
res_msg = {
|
|
'value': len(value)
|
|
}
|
|
# 简历渠道
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 招聘职位总人数数
|
|
@router.post("/interview_job_need_num_form")
|
|
async def interview_job_need_num_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 职位招聘人数 """
|
|
job_data = await crud.jobs.all_some_field(db)
|
|
value = [i['job_num'] for i in job_data]
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
res_msg = {
|
|
'value': sum(value)
|
|
}
|
|
# 简历渠道
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 渠道质量报表
|
|
@router.post("/owner_form")
|
|
async def owner_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 渠道质量报表 """
|
|
await interview.init()
|
|
res = interview.get_owner_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 简历渠道
|
|
owner_dict = {1: '前程无忧', 2: '人才库', 3: '智联招聘', 4: 'Boss直聘', 5: '58同城', 6: '拉勾'}
|
|
chk_data = {
|
|
'前程无忧': [],
|
|
'人才库': [],
|
|
'智联招聘': [],
|
|
'Boss直聘': [],
|
|
'58同城': [],
|
|
'拉勾': []
|
|
}
|
|
for i in data.values():
|
|
owner_name = owner_dict[i['owner_name']]
|
|
i_data = deepcopy(i)
|
|
chk_data[owner_name].append(i_data)
|
|
|
|
res_msg = {
|
|
'前程无忧': {
|
|
'count': 0
|
|
},
|
|
'人才库': {
|
|
'count': 0
|
|
},
|
|
'智联招聘': {
|
|
'count': 0
|
|
},
|
|
'Boss直聘': {
|
|
'count': 0
|
|
},
|
|
'58同城': {
|
|
'count': 0
|
|
},
|
|
'拉勾': {
|
|
'count': 0
|
|
}
|
|
}
|
|
|
|
for key, data_list in chk_data.items():
|
|
count_num = len(data_list)
|
|
offer_num = len([1 for i in data_list if i['interview_stage'] >= 4])
|
|
work_num = len([1 for i in data_list if i['interview_stage'] >= 7])
|
|
|
|
if offer_num:
|
|
offer_chance = round(offer_num / count_num, 2)
|
|
else:
|
|
offer_chance = 0
|
|
|
|
if work_num:
|
|
work_chance = round(work_num / count_num, 2)
|
|
else:
|
|
work_chance = 0
|
|
res_msg[key]['count'] = count_num
|
|
res_msg[key]['offer_num'] = offer_num
|
|
res_msg[key]['work_num'] = work_num
|
|
res_msg[key]['offer_chance'] = offer_chance
|
|
res_msg[key]['work_chance'] = work_chance
|
|
res_data = []
|
|
for k, v in res_msg.items():
|
|
v.update({'owner_name': k})
|
|
res_value = deepcopy(v)
|
|
res_data.append(res_value)
|
|
level_list = {
|
|
"owner_name": "渠道",
|
|
"count": "总数",
|
|
"offer_num": "面试通过",
|
|
"work_num": "入职人数",
|
|
"offer_chance": "面试通过率",
|
|
"work_chance": "入职率",
|
|
}
|
|
res_true_data = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_back_data = {
|
|
'data': res_true_data,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_back_data)
|
|
|
|
|
|
# 渠道效果报表
|
|
@router.post("/owner_effect")
|
|
async def owner_effect(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 渠道效果报表 """
|
|
await interview.init()
|
|
res = interview.get_owner_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 简历渠道
|
|
owner_dict = {1: '前程无忧', 2: '人才库', 3: '智联招聘', 4: 'Boss直聘', 5: '58同城', 6: '拉勾'}
|
|
chk_data = {
|
|
'前程无忧': [],
|
|
'人才库': [],
|
|
'智联招聘': [],
|
|
'Boss直聘': [],
|
|
'58同城': [],
|
|
'拉勾': [],
|
|
}
|
|
for i in data.values():
|
|
owner_name = owner_dict[i['owner_name']]
|
|
i_data = deepcopy(i)
|
|
chk_data[owner_name].append(i_data)
|
|
|
|
res_msg = {
|
|
'前程无忧': {
|
|
'count': 0
|
|
},
|
|
'人才库': {
|
|
'count': 0
|
|
},
|
|
'智联招聘': {
|
|
'count': 0
|
|
},
|
|
'Boss直聘': {
|
|
'count': 0
|
|
},
|
|
'58同城': {
|
|
'count': 0
|
|
},
|
|
'拉勾': {
|
|
'count': 0
|
|
}
|
|
}
|
|
|
|
for key, data_list in chk_data.items():
|
|
count_num = len(data_list)
|
|
start_num = len([1 for i in data_list if i['interview_stage'] >= 1]) # 初筛
|
|
screen_num = len([1 for i in data_list if i['interview_stage'] >= 2]) # 复筛
|
|
exam_num = len([1 for i in data_list if i['interview_stage'] >= 3]) # 面试
|
|
offer_num = len([1 for i in data_list if i['interview_stage'] >= 4]) # offer
|
|
work_num = len([1 for i in data_list if i['interview_stage'] >= 7]) # 入职
|
|
res_msg[key]['count'] = count_num
|
|
res_msg[key]['start_num'] = start_num
|
|
res_msg[key]['screen_num'] = screen_num
|
|
res_msg[key]['exam_num'] = exam_num
|
|
res_msg[key]['offer_num'] = offer_num
|
|
res_msg[key]['work_num'] = work_num
|
|
res_msg[key]['year_money'] = 0
|
|
res_msg[key]['one_money'] = 0
|
|
year = interview.where.get('start_time', '2022').split('-')[0]
|
|
owner_info = await crud.owner_info.find_owner_some(db, where={'year': year},
|
|
findlist=['owner_name', 'year_money'])
|
|
for i in owner_info:
|
|
if i['owner_name'] in res_msg:
|
|
res_msg[i['owner_name']]['year_money'] = i['year_money']
|
|
if res_msg[i['owner_name']]['count'] != 0:
|
|
res_msg[i['owner_name']]['one_money'] = res_msg[i['owner_name']]['year_money'] / res_msg[i['count']][
|
|
'one_money']
|
|
res_data = []
|
|
for k, v in res_msg.items():
|
|
v.update({'owner_name': k})
|
|
res_value = deepcopy(v)
|
|
res_data.append(res_value)
|
|
level_list = {
|
|
"owner_name": "渠道",
|
|
"count": "总数",
|
|
"start_num": "推荐简历",
|
|
"screen_num": "有效简历",
|
|
"exam_num": "到场面试数",
|
|
"offer_num": "面试通过",
|
|
"work_num": "入职人数",
|
|
"year_money": "成本",
|
|
"one_money": "人均成本",
|
|
}
|
|
res_true_msg = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_true_data = {
|
|
'data': res_true_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_true_data)
|
|
|
|
|
|
# 招聘趋势分析报表
|
|
@router.post("/interview_trend_form")
|
|
async def interview_trend_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 招聘趋势分析报表 """
|
|
await interview.init()
|
|
res = interview.get_trend_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
sdate = res['sdate']
|
|
edate = res['edate']
|
|
days = get_every_days(sdate, edate)
|
|
res_msg = {}
|
|
for i in days:
|
|
res_msg[str(i)] = {
|
|
'初筛简历数': 0,
|
|
'初筛': 0,
|
|
'创建面试的申请数': 0
|
|
}
|
|
for chk_data in data.values():
|
|
chk_date = datetime.strftime(chk_data['date'], '%Y-%m-%d')
|
|
if chk_date not in res_msg:
|
|
continue
|
|
chk_stage = chk_data['interview_stage']
|
|
count_num = chk_data['value']
|
|
if chk_stage >= 1:
|
|
res_msg[chk_date]['初筛简历数'] += 1 * count_num
|
|
if chk_stage >= 2:
|
|
res_msg[chk_date]['初筛'] += 1 * count_num
|
|
if chk_stage >= 3:
|
|
res_msg[chk_date]['创建面试的申请数'] += 1 * count_num
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 年度招聘趋势报表
|
|
@router.post("/year_trend_form")
|
|
async def year_trend_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 招聘趋势分析报表 """
|
|
await interview.init()
|
|
res = interview.get_year_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
sdate = res['sdate']
|
|
edate = res['edate']
|
|
months = get_every_months(sdate, edate)
|
|
res_msg = {}
|
|
for i in months:
|
|
res_msg[str(i)] = {
|
|
'start_num': 0,
|
|
'ok_num': 0,
|
|
'exam_num': 0,
|
|
'exam_pass_num': 0,
|
|
'offer_num': 0,
|
|
'work_num': 0,
|
|
'work_ok_num': 0,
|
|
'out_num': 0,
|
|
'out_self_num': 0,
|
|
'out_must_num': 0
|
|
}
|
|
|
|
for chk_data in data.values():
|
|
chk_date = datetime.strftime(chk_data['date'], '%Y-%m')
|
|
if chk_date not in res_msg:
|
|
continue
|
|
chk_stage = chk_data['interview_stage']
|
|
count_num = chk_data['value']
|
|
if chk_stage >= 1:
|
|
res_msg[chk_date]['start_num'] += 1 * count_num
|
|
if chk_stage >= 2:
|
|
res_msg[chk_date]['ok_num'] += 1 * count_num
|
|
if chk_stage >= 3:
|
|
res_msg[chk_date]['exam_num'] += 1 * count_num
|
|
if chk_stage >= 4:
|
|
res_msg[chk_date]['exam_pass_num'] += 1 * count_num
|
|
if chk_stage >= 5:
|
|
res_msg[chk_date]['offer_num'] += 1 * count_num
|
|
if chk_stage >= 7:
|
|
res_msg[chk_date]['work_num'] += 1 * count_num
|
|
if chk_stage >= 8:
|
|
res_msg[chk_date]['work_ok_num'] += 1 * count_num
|
|
if chk_stage == 9:
|
|
res_msg[chk_date]['out_num'] += 1 * count_num
|
|
res_msg[chk_date]['out_self_num'] += 1 * count_num
|
|
if chk_stage == 10:
|
|
res_msg[chk_date]['out_num'] += 1 * count_num
|
|
res_msg[chk_date]['out_must_num'] += 1 * count_num
|
|
res_data = []
|
|
for k, v in res_msg.items():
|
|
v.update({'time': k})
|
|
res_v = deepcopy(v)
|
|
res_data.append(res_v)
|
|
level_list = {
|
|
"time": "时间",
|
|
"start_num": "简历推荐数",
|
|
"ok_num": "有效简历数",
|
|
"exam_num": "到场面试数",
|
|
"exam_pass_num": "面试通过",
|
|
"offer_num": "offer发出数",
|
|
"work_num": "入职人数",
|
|
"work_ok_num": "转正人数",
|
|
"out_num": "离职人数",
|
|
"out_self_num": "主动离职",
|
|
"out_must_num": "被动离职"
|
|
}
|
|
res_true_data = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_back_data = {
|
|
'data': res_true_data,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_back_data)
|
|
|
|
|
|
# 年度岗位招聘数据报表
|
|
@router.post("/year_job_form")
|
|
async def year_job_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 岗位招聘数据分析报表 """
|
|
await interview.init()
|
|
res = interview.year_job_form_sql()
|
|
sql = res['sql']
|
|
data = await ck_db.execute(sql)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
# 取出job和部门
|
|
job_ids = set([j_data['job_id'] for j_data in data.values()])
|
|
job_ids = list(job_ids)
|
|
job_datas = await crud.jobs.find_job_some(db, job_ids)
|
|
job_dict = {job['job_id']: {'name': job['job_name'], 'sector': job['job_sector']} for job in job_datas}
|
|
sdate = res['sdate']
|
|
edate = res['edate']
|
|
chk_type = res['chk_type']
|
|
if chk_type == 'day':
|
|
months = get_every_days(sdate, edate)
|
|
elif chk_type == 'week':
|
|
months = get_every_weeks(sdate, edate)
|
|
else:
|
|
months = get_every_months(sdate, edate)
|
|
res_msg = {}
|
|
for i in months:
|
|
res_msg[str(i)] = {}
|
|
for job_id in job_ids:
|
|
res_msg[str(i)][job_id] = {
|
|
'start_num': 0,
|
|
'ok_num': 0,
|
|
'exam_num': 0,
|
|
'exam_pass_num': 0,
|
|
'offer_num': 0,
|
|
'work_num': 0,
|
|
'out_num': 0
|
|
}
|
|
|
|
for chk_data in data.values():
|
|
if chk_type == 'month':
|
|
chk_date = datetime.strftime(chk_data['date'], '%Y-%m')
|
|
else:
|
|
chk_date = datetime.strftime(chk_data['date'], '%Y-%m-%d')
|
|
|
|
if chk_date not in res_msg:
|
|
continue
|
|
chk_stage = chk_data['interview_stage']
|
|
count_num = chk_data['value']
|
|
chk_job_id = chk_data['job_id']
|
|
if chk_stage >= 1:
|
|
res_msg[chk_date][chk_job_id]['start_num'] += 1 * count_num
|
|
if chk_stage >= 2:
|
|
res_msg[chk_date][chk_job_id]['ok_num'] += 1 * count_num
|
|
if chk_stage >= 3:
|
|
res_msg[chk_date][chk_job_id]['exam_num'] += 1 * count_num
|
|
if chk_stage >= 4:
|
|
res_msg[chk_date][chk_job_id]['exam_pass_num'] += 1 * count_num
|
|
if chk_stage >= 5:
|
|
res_msg[chk_date][chk_job_id]['offer_num'] += 1 * count_num
|
|
if chk_stage >= 7:
|
|
res_msg[chk_date][chk_job_id]['work_num'] += 1 * count_num
|
|
if chk_stage >= 9:
|
|
res_msg[chk_date][chk_job_id]['out_num'] += 1 * count_num
|
|
res_data = {}
|
|
for k, v in res_msg.items():
|
|
res_data[k] = {}
|
|
for k1, v1 in v.items():
|
|
if k1 in job_dict:
|
|
if job_dict[k1]['sector'] not in res_data[k]:
|
|
res_data[k][job_dict[k1]['sector']] = {}
|
|
res_data[k][job_dict[k1]['sector']].update({job_dict[k1]['name']: v1})
|
|
else:
|
|
res_data[k]['其他'] = {}
|
|
res_data[k]['其他'].update({'其他': v1})
|
|
res_data1 = []
|
|
for k, v in res_data.items():
|
|
data1 = {'time': k}
|
|
for k1, v1 in v.items():
|
|
data2 = {'date_name': k1}
|
|
for k2, v2 in v1.items():
|
|
v2.update(data1)
|
|
v2.update(data2)
|
|
v2.update({'job_name': k2})
|
|
true_data = deepcopy(v2)
|
|
res_data1.append(true_data)
|
|
level_list = {
|
|
"time": "时间",
|
|
"date_name": "部门",
|
|
"job_name": "职位",
|
|
"start_num": "简历推荐数",
|
|
"ok_num": "有效简历数",
|
|
"exam_num": "到场面试数",
|
|
"exam_pass_num": "面试通过",
|
|
"offer_num": "offer发出数",
|
|
"work_num": "入职人数",
|
|
"out_num": "离职人数"
|
|
}
|
|
res_true_msg = {
|
|
'data': res_data1,
|
|
'level_list': level_list,
|
|
}
|
|
res_true_data = {
|
|
'data': res_true_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_true_data)
|
|
|
|
|
|
# 年度入离职数据报表
|
|
@router.post("/year_in_out")
|
|
async def year_in_out(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 年度入离职数据报表 """
|
|
await interview.init()
|
|
res = interview.year_in_out_sql()
|
|
sql_in = res['sql_in']
|
|
sql_out = res['sql_out']
|
|
data_in = await ck_db.execute(sql_in)
|
|
data_out = await ck_db.execute(sql_out)
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
sdate = res['sdate']
|
|
edate = res['edate']
|
|
months = get_every_months(sdate, edate)
|
|
res_msg = {
|
|
}
|
|
for i in months:
|
|
res_msg[str(i)] = {}
|
|
res_msg[str(i)]['入职'] = 0
|
|
res_msg[str(i)]['离职'] = 0
|
|
|
|
# 入职数据处理
|
|
for in_data in data_in.values():
|
|
in_date = datetime.strftime(in_data['date'], '%Y-%m')
|
|
if in_date not in res_msg:
|
|
continue
|
|
value = in_data['value']
|
|
res_msg[in_date]['入职'] += value
|
|
|
|
# 离职数据处理
|
|
for out_data in data_out.values():
|
|
out_date = datetime.strftime(out_data['date'], '%Y-%m')
|
|
if out_date not in res_msg:
|
|
continue
|
|
value = out_data['value']
|
|
res_msg[out_date]['离职'] += value
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|
|
|
|
|
|
# 查询入职人员信息
|
|
@router.post("/find_worker_form")
|
|
async def find_worker_form(
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 人才密度报表 """
|
|
await interview.init()
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
data = await crud.worker_info.find_worker_some(db, findlist=interview.find_column)
|
|
if not data:
|
|
return schemas.Msg(code=-9, msg='无数据', data=None)
|
|
res_msg = {
|
|
'未评级': [i['name'] for i in data if i['job_level'] == '未评级'],
|
|
'p1-p3': [i['name'] for i in data if i['job_level'] in ['p1', 'p2', 'p3']],
|
|
'p4': [i['name'] for i in data if i['job_level'] == 'p4'],
|
|
'p5': [i['name'] for i in data if i['job_level'] == 'p5'],
|
|
'p6': [i['name'] for i in data if i['job_level'] == 'p6'],
|
|
'p7': [i['name'] for i in data if i['job_level'] == 'p7'],
|
|
'p8': [i['name'] for i in data if i['job_level'] == 'p8'],
|
|
'm1': [i['name'] for i in data if i['job_level'] == 'm1'],
|
|
'm2': [i['name'] for i in data if i['job_level'] == 'm2'],
|
|
'm3': [i['name'] for i in data if i['job_level'] == 'm3'],
|
|
'm4': [i['name'] for i in data if i['job_level'] == 'm4'],
|
|
'总人数': len(data)
|
|
}
|
|
res_data = []
|
|
res_msg1 = {
|
|
'title': '数量',
|
|
'未评级': len(res_msg['未评级']),
|
|
'p1-p3': len(res_msg['p1-p3']),
|
|
'p4': len(res_msg['p4']),
|
|
'p5': len(res_msg['p5']),
|
|
'p6': len(res_msg['p6']),
|
|
'p7': len(res_msg['p7']),
|
|
'p8': len(res_msg['p8']),
|
|
'm1': len(res_msg['m1']),
|
|
'm2': len(res_msg['m2']),
|
|
'm3': len(res_msg['m3']),
|
|
'm4': len(res_msg['m4']),
|
|
}
|
|
res_data.append(res_msg1)
|
|
res_msg2 = {
|
|
'title': '占比',
|
|
'未评级': round(res_msg1['未评级'] / res_msg['总人数'], 2),
|
|
'p1-p3': round(res_msg1['p1-p3'] / res_msg['总人数'], 2),
|
|
'p4': round(res_msg1['p4'] / res_msg['总人数'], 2),
|
|
'p5': round(res_msg1['p5'] / res_msg['总人数'], 2),
|
|
'p6': round(res_msg1['p6'] / res_msg['总人数'], 2),
|
|
'p7': round(res_msg1['p7'] / res_msg['总人数'], 2),
|
|
'p8': round(res_msg1['p8'] / res_msg['总人数'], 2),
|
|
'm1': round(res_msg1['m1'] / res_msg['总人数'], 2),
|
|
'm2': round(res_msg1['m2'] / res_msg['总人数'], 2),
|
|
'm3': round(res_msg1['m3'] / res_msg['总人数'], 2),
|
|
'm4': round(res_msg1['m4'] / res_msg['总人数'], 2),
|
|
}
|
|
res_data.append(res_msg2)
|
|
level_list = {
|
|
'title': '职级',
|
|
'未评级': '未评级',
|
|
'p1-p3': 'p1-p3',
|
|
'p4': 'p4',
|
|
'p5': 'p5',
|
|
'p6': 'p6',
|
|
'p7': 'p7',
|
|
'p8': 'p8',
|
|
'm1': 'm1',
|
|
'm2': 'm2',
|
|
'm3': 'm3',
|
|
'm4': 'm4'
|
|
}
|
|
res_true_msg = {
|
|
'data': res_data,
|
|
'level_list': level_list
|
|
}
|
|
res_true_data = {
|
|
'data': res_true_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_true_data)
|
|
|
|
|
|
# 查询统计数据
|
|
@router.post("/find_count_info")
|
|
async def find_count_info(
|
|
|
|
request: Request,
|
|
interview: InterviewDo = Depends(InterviewDo),
|
|
ck_db: CKDrive = Depends(get_ck_db),
|
|
db: AsyncIOMotorDatabase = Depends(get_database),
|
|
current_user: schemas.UserDB = Depends(deps.get_current_user)
|
|
) -> schemas.Msg:
|
|
""" 在职人员年份分布 """
|
|
await interview.init()
|
|
|
|
# 获取报表相关参数
|
|
table_id = interview.data_in.get('table_id', '')
|
|
if not table_id:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
|
|
table_data = await crud.api_interview_tables.get_one_table(db, table_id)
|
|
if not table_data:
|
|
return schemas.Msg(code=200, msg='报表数据错误', data={})
|
|
data = await crud.count_in_worker.find_count_some(db)
|
|
true_index = 0
|
|
max_num = 0
|
|
for index, i in enumerate(data):
|
|
if len(i.keys()) > max_num:
|
|
true_index = index
|
|
index_key = [k for k in data[true_index].keys()]
|
|
level_list = {i: i for i in index_key}
|
|
level_list.update({
|
|
'count_id': '月份'
|
|
})
|
|
res_msg = {
|
|
'data': data,
|
|
'level_list': level_list
|
|
}
|
|
res_data = {
|
|
'data': res_msg,
|
|
'table_data': table_data
|
|
}
|
|
return schemas.Msg(code=200, msg='ok', data=res_data)
|