rate-sys-template/Mods/Rate/RateFlow/Router.py

import datetime

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session

from Context.common import CompanyUserTokenDataModel, company_user_auth_util, common_db, mg_db, AdminUserTokenDataModel, \
    admin_user_auth_util
from Utils.SqlAlchemyUtils import QueryParams, query_common
from . import Crud
from . import Schemas
from .Models import RateFlow, RateFlowNode
from Utils.MongoUtils import MongoConnect
from ..RateUtil import RateUtil
from ..Types.RateRes import RateRes

"""
一个流程所需的基本接口
"""

router = APIRouter(prefix="/rate_flow")


@router.post("/create_rate_flow_from_company_user", summary="企业用户创建评级流程", tags=["评级流程"])
def func(token: CompanyUserTokenDataModel = Depends(company_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db)):
    company_name = token.company_name
    rate_flow = Crud.create_rate_flow(db, company_name)
    nodes = ["表单填报", "三方数据录入", "后台审核校正", "评级"]
    for node_num in range(len(nodes)):
        node_name = nodes[node_num]
        Crud.create_rate_flow_node(db, node_num=node_num, node_name=node_name, rate_process_id=rate_flow.id)
    return {"message": "创建成功", "code": 200}


@router.post("/get_rate_flow_by_id", summary="获取评级流程数据", response_model=Schemas.GetRateFlowByIdRes,
             tags=["评级流程"])
def func(req: Schemas.GetRateFlowByIdReq,
         token: CompanyUserTokenDataModel = Depends(company_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    rate_flow_data = db.query(RateFlow).filter(RateFlow.id == req.id).first()
    nodes = Crud.get_rate_flow_all_nodes(RateFlow.id, db, mongodb, with_content=True)
    rate_flow_data.nodes = nodes
    return rate_flow_data


@router.post("/get_rate_flow_by_company_user", summary="获取评级列表",
             response_model=Schemas.GetRateFlowByCompanyUserRes, tags=["评级流程"])
def func(token: CompanyUserTokenDataModel = Depends(company_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    items = [item for item in db.query(RateFlow).filter(RateFlow.company_name == token.company_name)]
    return items


@router.post("/rate_form_save", summary="表单填报", tags=['评级节点'])
def func(req: Schemas.RateFormSaveReq,
         token: CompanyUserTokenDataModel = Depends(company_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    node = db.query(RateFlowNode).filter(
        RateFlowNode.rate_process_id == req.rate_flow_id and RateFlowNode.node_name == '表单填报').first()
    index_from_data = RateUtil.parse_org_form_data_func(req.data)
    Crud.save_rate_flow_node(node.id, {"原始填报数据": req.data, "填报解析数据": index_from_data}, db, mongodb)
    Crud.change_rate_node_status(db, node.id, "完成")
    return {"message": "保存成功", "code": 200}


# 管理端接口
@router.post("/load_api_data", summary="三方数据录入", tags=['评级节点'])
def func(req: Schemas.LoadApiDataReq,
         token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    rate_flow = Crud.get_rate_flow(db, req.rate_flow_id)
    company_name = rate_flow.company_name
    node = db.query(RateFlowNode).filter(
        RateFlowNode.rate_process_id == req.rate_flow_id and RateFlowNode.node_name == '三方数据录入').first()
    # todo: 三方数据录入
    data = RateUtil.load_api_data_func(company_name)
    Crud.save_rate_flow_node(node.id, data, db, mongodb)
    Crud.change_rate_node_status(db, node.id, "完成")
    return {"message": "保存成功", "code": 200}


# 管理端接口
@router.post("/save_man_data", summary="后台审核校正", tags=['评级节点'])
def func(req: Schemas.SaveManDataReq,
         token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    node = db.query(RateFlowNode).filter(
        RateFlowNode.rate_process_id == req.rate_flow_id and RateFlowNode.node_name == '后台审核校正').first()
    # todo: 后台审核校正
    Crud.save_rate_flow_node(node.id, req.data, db, mongodb)
    Crud.change_rate_node_status(db, node.id, "完成")
    return {"message": "保存成功", "code": 200}


# 管理端接口
@router.post("/do_rate", summary="评级", tags=['评级节点'])
def func(req: Schemas.DoRateReq,
         token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend),
         db: Session = Depends(common_db.get_db), mongodb: MongoConnect = Depends(mg_db.get_db)):
    node = db.query(RateFlowNode).filter(
        RateFlowNode.rate_process_id == req.rate_flow_id and RateFlowNode.node_name == '评级').first()
    # todo: 进行评级
    nodes = Crud.get_rate_flow_all_nodes(req.rate_flow_id, db, mongodb, with_content=True)
    nodes_dic = {item['node_name']: item for item in nodes}
    index_data_merge = RateUtil.merge_index_data(nodes_dic['表单填报']['content']['填报解析数据'],
                                                 nodes_dic['三方数据']['content'],
                                                 nodes_dic['后台审核校正']['content'])
    rate_res = RateUtil.cal_index(index_data_merge)
    Crud.save_rate_flow_node(node.id, rate_res, db, mongodb)
    Crud.change_rate_node_status(db, node.id, "完成")
    Crud.rate_flow_update(db,
                          Schemas.RateFlowUpdateInfo(
                              rate_date=datetime.datetime.now(),
                              rate_level=rate_res.content.level,
                              rate_scope=rate_res.content.total_score,
                              status="完成"
                          )
                          )
    return {"message": "保存成功", "code": 200}


# todo: 代码生成，评级结果的增删改查接口
# @router.post("/rate_res/add", summary="添加评级结果", response_model=Schemas.RateFlowAddRes)
# def rate_flow_add(req: Schemas.RateFlowAddReq,
#                   token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend),
#                   db: Session = Depends(common_db.get_db)):
#     item = Crud.rate_flow_add(db, req)
#     return Schemas.RateFlowAddRes(**item.to_dict())


@router.post("/rate_res/delete", summary="删除评级结果", tags=["评级结果"])
def rate_flow_delete(req: Schemas.RateFlowDeleteReq, db: Session = Depends(common_db.get_db),
                     token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend)
                     ):
    Crud.rate_flow_delete(db, req.id)
    return "删除成功"


@router.post("/rate_res/update", summary="更新评级结果", response_model=Schemas.RateFlowUpdateRes, tags=["评级结果"])
def rate_flow_update(req: Schemas.RateFlowUpdateReq, db: Session = Depends(common_db.get_db),
                     token: AdminUserTokenDataModel = Depends(admin_user_auth_util.token_data_depend)):
    item = Crud.rate_flow_update(db, req)
    return Schemas.RateFlowUpdateRes(**item.to_dict())


@router.post("/rate_res/get", summary="获取评级结果", response_model=Schemas.RateFlowGetRes, tags=["评级结果"])
def rate_flow_get(req: Schemas.RateFlowGetReq, db: Session = Depends(common_db.get_db)):
    item = Crud.rate_flow_get(db, req.id)
    if not item:
        raise HTTPException(detail="未查询到信息", status_code=404)
    return Schemas.RateFlowGetRes(**item.to_dict())


@router.post("/rate_res/query", summary="查询评级结果", response_model=Schemas.RateFlowQueryRes, tags=["评级结果"])
def rate_flow_query(req: Schemas.RateFlowQueryReq, db: Session = Depends(common_db.get_db)):
    count, query = Crud.rate_flow_query(db, req)
    items = [Schemas.RateFlowInfo(**item.to_dict()) for item in query]
    return Schemas.RateFlowQueryRes(count=count, items=items)


@router.post("/rate_res/query_common", summary="通用查询评级结果",
             response_model=Schemas.RateFlowQueryRes, tags=["评级结果"])
def rate_flow_query_common(req: QueryParams, db: Session = Depends(common_db.get_db)):
    count, query = query_common(db, RateFlow, req)
    items = [Schemas.RateFlowInfo(**item.to_dict()) for item in query]
    return Schemas.RateFlowQueryRes(count=count, items=items)