wd-smebiz/mods/smebiz_rate/company_rate/router.py

import json

import requests
from fastapi import APIRouter, Depends, HTTPException, Response
from sqlalchemy.orm import Session
from context.common import common_db, CompanyUserTokenDataModel, company_user_auth_util, auth_util, conf
from . import schemas
from . import crud
from utils.sqlalchemy_common_utils import QueryParams, query_common
from .models import CompanyRate
from .rate_utils.utils import load_report_need_data
from ..company_user.models import CompanyUser

router = APIRouter(tags=["公司评级数据"])


@router.post("/company_rate/add", summary="添加公司评级数据", response_model=schemas.CompanyRateAddRes)
def company_rate_add(req: schemas.CompanyRateAddReq, db: Session = Depends(common_db.get_db),
                     token_data: CompanyUserTokenDataModel = Depends(company_user_auth_util.token_data_depend)):
    req.company_name = token_data.company_name
    item = crud.company_rate_add(db, req)
    return schemas.CompanyRateAddRes(**item.to_dict())


@router.post("/company_rate/create", summary="创建公司评级", response_model=schemas.CompanyRateAddRes)
def company_rate_add(req: schemas.CompanyRateAddReq, db: Session = Depends(common_db.get_db),
                     token_data: auth_util.tokenDataModel = Depends(auth_util.token_data_depend)):
    item = crud.company_rate_add(db, req)
    return schemas.CompanyRateAddRes(**item.to_dict())


@router.post("/company_rate/upload_file", summary="问卷数据上传")
def company_rate_file_data_load(req: schemas.CompanyRateFileDataLoadReq, db: Session = Depends(common_db.get_db),
                                token_data: auth_util.tokenDataModel = Depends(auth_util.token_data_depend)):
    item = crud.company_rate_file_data_load(db, req.id, req.file_md)
    return "成功"


@router.post("/company_rate/delete", summary="删除公司评级数据")
def company_rate_delete(req: schemas.CompanyRateDeleteReq, db: Session = Depends(common_db.get_db)):
    crud.company_rate_delete(db, req.id)
    return "删除成功"


@router.post("/company_rate/update", summary="更新公司评级数据", response_model=schemas.CompanyRateUpdateRes)
def company_rate_update(req: schemas.CompanyRateUpdateReq, db: Session = Depends(common_db.get_db)):
    item = crud.company_rate_update(db, req)
    return schemas.CompanyRateUpdateRes(**item.to_dict())


@router.post("/company_rate/get", summary="获取公司评级数据", response_model=schemas.CompanyRateGetRes)
def company_rate_get(req: schemas.CompanyRateGetReq, db: Session = Depends(common_db.get_db)):
    item = crud.company_rate_get(db, req.id)
    if not item:
        raise HTTPException(detail="未查询到信息", status_code=404)
    return schemas.CompanyRateGetRes(**item.to_dict())


@router.post("/company_rate/query", summary="查询公司评级数据", response_model=schemas.CompanyRateQueryRes)
def company_rate_query(req: schemas.CompanyRateQueryReq, db: Session = Depends(common_db.get_db)):
    count, query = crud.company_rate_query(db, req)
    items = [schemas.CompanyRateInfo(**item.to_lite_dict()) for item in query]
    return schemas.CompanyRateQueryRes(count=count, items=items)


@router.post("/company_rate/ranking", summary="查询公司评级排名数据", response_model=schemas.CompanyRateQueryRes)
def company_rate_query(req: schemas.CompanyRateQueryReq, db: Session = Depends(common_db.get_db)):
    params_dict = req.dict()
    query = db.query(CompanyRate).filter(CompanyRate.publish_state == '已披露').order_by(CompanyRate.rate_scope.desc())
    db_model = CompanyRate
    for key, value in params_dict.items():
        if key not in ['page', 'page_size'] and value is not None:
            if key == 'rate_level':
                query = query.filter(getattr(db_model, key) == value)
                continue
            if type(value) == str:
                query = query.filter(getattr(db_model, key).like(f'%{value}%'))
            elif type(value) in [int, float, bool]:
                query = query.filter_by(**{key: value})
            else:
                query = query.filter(getattr(db_model, key) == value)
    count = query.count()
    page = None
    page_size = None
    if 'page' in params_dict:
        page = params_dict['page']
    if 'page_size' in params_dict:
        page_size = params_dict['page_size']
        # 页数不超过100
    if page is not None and page_size is not None:
        page_size = min(page_size, 100)
        query = query.offset((page - 1) * page_size).limit(page_size).all()
    items = [schemas.CompanyRateInfo(**item.to_rank_dict()) for item in query]
    return schemas.CompanyRateQueryRes(count=count, items=items)


@router.post("/company_rate/query_common", summary="通用查询公司评级数据",
             response_model=schemas.CompanyRateQueryRes)
def company_rate_query_common(req: QueryParams, db: Session = Depends(common_db.get_db)):
    count, query = query_common(db, CompanyRate, req)
    items = [schemas.CompanyRateInfo(**item.to_lite_dict()) for item in query]
    return schemas.CompanyRateQueryRes(count=count, items=items)


@router.post("/company_rate/company_rate", summary="评级")
def company_rate(req: schemas.CompanyRateReq, db: Session = Depends(common_db.get_db)):
    res = crud.company_rate(db, req.id)
    return res


@router.post("/company_rate/load_api_data_to_db", summary="三方接口数据导入", response_model=schemas.CompanyRateGetRes)
def company_rate(req: schemas.CompanyRateGetReq, db: Session = Depends(common_db.get_db)):
    res = crud.load_api_data_to_db(db, req.id)
    return res.to_dict()


@router.post("/company_rate/load_api_data", summary="三方接口数据获取")
def company_rate(req: schemas.CompanyRateGetReq, db: Session = Depends(common_db.get_db)):
    item = db.query(CompanyRate).filter(CompanyRate.id == req.id).first()
    if item:
        res = crud.load_api_data(item.company_name)
        return res
    else:
        raise HTTPException(detail="未查询到公司信息", status_code=404)


@router.post("/company_rate/get_full_info", summary="获取详细信息")
def company_rate(req: schemas.CompanyRateGetReq, db: Session = Depends(common_db.get_db)):
    res = crud.get_full_info(db, req.id)
    return res


@router.post("/company_rate/get_report_admin", summary="管理端获取评级报告")
def get_report(req: schemas.GetReport, db: Session = Depends(common_db.get_db),
               token_data: auth_util.tokenDataModel = Depends(auth_util.token_data_depend)
               ):
    data = load_report_need_data(db, req.id)
    response = requests.post(f'{conf["rate_utils"]["host"]}/api/report_generation/generation', json.dumps(
        data), timeout=8)
    # print(response.json())
    return Response(content=response.content, headers=dict(response.headers))
#########