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

from Context.common import mg_db, common_db

from sqlalchemy.orm import Session

from .Models import RateFlow, RateFlowNode
from .Schemas import *
from Utils.MongoUtils import MongoConnect
from Utils.TimeSerialNumUtils import create_time_serial_num


def create_rate_flow(db: Session, company_name, company_user_id):
    item = RateFlow()
    item.company_name = company_name
    item.status = "进行"

    db.add(item)
    db.commit()
    db.refresh(item)
    return item


def create_rate_flow_node(db: Session, node_num, node_name, rate_process_id):
    item = RateFlowNode()
    item.node_num = node_num
    item.node_name = node_name
    item.rate_process_id = rate_process_id

    db.add(item)
    db.commit()
    return True


def get_rate_flow_all_nodes(_id: str, db: Session, mongodb: MongoConnect, with_content=False):
    item = db.query(RateFlow).filter_by(id=_id).first()

    if not item:
        return False
    node_list=[]
    for node in item.nodes:
        node_data = {
            "node_id": node.id,
            "node_num": node.node_num,
            "node_name": node.node_name,
            "status": node.status,
        }
        if with_content:
            node_data['content'] = mongodb.find_data_by_id(dbname="打分评级流程", sheet=node.node_name, _id=node.obj_id)
        node_list.append(node_data)
    return node_list


def save_rate_flow_node(node_id: str, data: dict, db: Session, mongodb: MongoConnect):
    # 查询节点信息
    node = db.query(RateFlowNode).filter_by(id=node_id).first()
    mongodb.replace_data_by_id("打分评级流程", node.node_name, node.obj_id, data)
    return True


def get_rate_flow(db, rate_flow_id: str):
    item = db.query(RateFlow).filter_by(id=rate_flow_id).first()
    return item


def edit_rate_status(db, rate_flow_id, status):
    data = {"status": status}
    db.query(RateFlow).filter_by(id=rate_flow_id).update(data)
    db.commit()
    return db.query(RateFlow).filter_by(id=rate_flow_id).first()


def change_rate_node_status(db, _id: str, status: str):
    update_data = {"status": status}
    db.query(RateFlowNode).filter_by(id=_id).update(update_data)
    db.commit()
    return db.query(RateFlowNode).filter_by(id=_id).first()


def delete_rate_flow(db, _id: str):
    db.query(RateFlow).filter_by(id=_id).delete()
    db.commit()
    return True


def delete_rate_flow_node(db, _id: str):
    db.query(RateFlowNode).filter_by(id=_id).delete()
    db.commit()
    return True


def get_rate_node_data(_id: str, db: Session, mongodb: MongoConnect):
    item = db.query(RateFlowNode).filter_by(id=_id).first()
    content = mongodb.find_data_by_id(dbname="打分评级流程", sheet=item.node_name, _id=item.obj_id)
    return content


def delete_rate_node_data(_id: str, db: Session, mongodb: MongoConnect):
    node_item = db.query(RateFlowNode).filter_by(id=_id).first()
    if not node_item:
        return False
    if node_item.obj_id:
        mongodb.delete_data_by_id(dbname="打分评级流程", sheet=node_item.node_name, _id=node_item.obj_id)
    db.query(RateFlowNode).filter_by(id=_id).update({"obj_id": None})
    db.commit()
    return True


##### 评级流程管理接口

def rate_flow_add(db: Session, data: RateFlowAddInfo):
    item = RateFlow(**data.dict())
    db.add(item)
    db.commit()
    db.refresh(item)
    return item


def rate_flow_delete(db: Session, item_id: str):
    db.query(RateFlow).filter_by(id=item_id).delete()
    db.commit()


def rate_flow_update(db: Session, data: RateFlowUpdateInfo):
    db.query(RateFlow).filter_by(id=data.id).update({key: v for key, v in data.dict().items() if v is not None})
    db.commit()
    item = db.query(RateFlow).filter_by(id=data.id).first()
    return item


def rate_flow_get(db: Session, item_id: str):
    item = db.query(RateFlow).filter_by(id=item_id).first()
    return item


def rate_flow_query(db: Session, params: RateFlowQuery):
    params_dict = params.dict()
    query = db.query(RateFlow)
    db_model = RateFlow
    for key, value in params_dict.items():
        if key not in ['page', 'page_size'] and value is not None:
            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()
    return count, query