780 lines
24 KiB
Python
780 lines
24 KiB
Python
"""工作流 CRUD（wf_process_def / wf_process_version / wf_node / wf_transition / wf_process_instance / wf_task）"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import math
|
||
from datetime import datetime
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
from sqlalchemy import and_, func, or_
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.core.utils import generate_uuid
|
||
from app.models.models import (
|
||
SysUser,
|
||
WfNode,
|
||
WfProcessDef,
|
||
WfProcessInstance,
|
||
WfProcessVersion,
|
||
WfTask,
|
||
WfTransition,
|
||
)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 流程定义 wf_process_def
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def _row_to_dict(t: WfProcessDef) -> Dict[str, Any]:
|
||
return {
|
||
"id": t.id,
|
||
"processCode": t.process_code,
|
||
"processName": t.process_name,
|
||
"status": t.status,
|
||
"tenantNo": t.tenant_no,
|
||
"orderNum": t.order_num if t.order_num is not None else 0,
|
||
"remark": t.remark or "",
|
||
"createTime": t.create_time.strftime("%Y-%m-%d %H:%M:%S") if t.create_time else "",
|
||
"updateTime": t.update_time.strftime("%Y-%m-%d %H:%M:%S") if t.update_time else "",
|
||
}
|
||
|
||
|
||
def list_process_defs(
|
||
db: Session,
|
||
*,
|
||
page: int = 1,
|
||
page_size: int = 10,
|
||
keyword: Optional[str] = None,
|
||
status: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_info=None,
|
||
) -> Tuple[List[Dict[str, Any]], int]:
|
||
def _filtered():
|
||
q0 = db.query(WfProcessDef).filter(WfProcessDef.del_flag == 0)
|
||
if tenant_no:
|
||
q0 = q0.filter(WfProcessDef.tenant_no == tenant_no)
|
||
if status is not None:
|
||
q0 = q0.filter(WfProcessDef.status == status)
|
||
kw = (keyword or "").strip()
|
||
if kw:
|
||
like = f"%{kw}%"
|
||
q0 = q0.filter(or_(WfProcessDef.process_name.like(like), WfProcessDef.process_code.like(like)))
|
||
if user_info:
|
||
from app.core.data_scope import apply_data_scope
|
||
q0 = apply_data_scope(q0, WfProcessDef, user_info, db, tenant_no)
|
||
return q0
|
||
|
||
total = _filtered().order_by(None).with_entities(func.count(WfProcessDef.id)).scalar() or 0
|
||
page = max(1, page)
|
||
page_size = min(max(1, page_size), 100)
|
||
rows = (
|
||
_filtered()
|
||
.order_by(WfProcessDef.create_time.desc())
|
||
.offset((page - 1) * page_size)
|
||
.limit(page_size)
|
||
.all()
|
||
)
|
||
|
||
result = []
|
||
for r in rows:
|
||
d = _row_to_dict(r)
|
||
ver = (
|
||
db.query(WfProcessVersion)
|
||
.filter(
|
||
and_(
|
||
WfProcessVersion.process_def_id == r.id,
|
||
WfProcessVersion.is_latest == "1",
|
||
WfProcessVersion.del_flag == 0,
|
||
)
|
||
)
|
||
.order_by(WfProcessVersion.version_no.desc())
|
||
.first()
|
||
)
|
||
d["latestVersion"] = ver.version_no if ver else None
|
||
result.append(d)
|
||
return result, int(total)
|
||
|
||
|
||
def get_process_def(db: Session, def_id: str) -> Optional[WfProcessDef]:
|
||
return (
|
||
db.query(WfProcessDef)
|
||
.filter(and_(WfProcessDef.id == def_id, WfProcessDef.del_flag == 0))
|
||
.first()
|
||
)
|
||
|
||
|
||
def process_code_exists(
|
||
db: Session, code: str, tenant_no: str, exclude_id: Optional[str] = None
|
||
) -> bool:
|
||
q = db.query(WfProcessDef).filter(
|
||
and_(WfProcessDef.process_code == code.strip(), WfProcessDef.tenant_no == tenant_no, WfProcessDef.del_flag == 0)
|
||
)
|
||
if exclude_id:
|
||
q = q.filter(WfProcessDef.id != exclude_id)
|
||
return q.first() is not None
|
||
|
||
|
||
def create_process_def(
|
||
db: Session,
|
||
*,
|
||
process_code: str,
|
||
process_name: str,
|
||
tenant_no: str,
|
||
status: Optional[str] = None,
|
||
order_num: Optional[int] = None,
|
||
remark: Optional[str] = None,
|
||
user_id: Optional[str] = None,
|
||
) -> WfProcessDef:
|
||
code = (process_code or "").strip()
|
||
if not code:
|
||
raise ValueError("流程编码不能为空")
|
||
if process_code_exists(db, code, tenant_no):
|
||
raise ValueError("流程编码已存在")
|
||
obj = WfProcessDef(
|
||
id=generate_uuid(),
|
||
process_code=code,
|
||
process_name=(process_name or "").strip(),
|
||
status=status or "1",
|
||
tenant_no=tenant_no,
|
||
order_num=order_num if order_num is not None else 0,
|
||
remark=(remark or "").strip() or None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(obj)
|
||
db.commit()
|
||
db.refresh(obj)
|
||
return obj
|
||
|
||
|
||
def update_process_def(
|
||
db: Session,
|
||
def_id: str,
|
||
*,
|
||
process_code: Optional[str] = None,
|
||
process_name: Optional[str] = None,
|
||
status: Optional[str] = None,
|
||
order_num: Optional[int] = None,
|
||
remark: Optional[str] = None,
|
||
user_id: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
) -> WfProcessDef:
|
||
obj = get_process_def(db, def_id)
|
||
if not obj:
|
||
raise ValueError("流程定义不存在")
|
||
if process_code is not None:
|
||
new_code = process_code.strip()
|
||
if not new_code:
|
||
raise ValueError("流程编码不能为空")
|
||
tn = tenant_no or obj.tenant_no
|
||
if new_code != obj.process_code and process_code_exists(db, new_code, tn, exclude_id=def_id):
|
||
raise ValueError("流程编码已存在")
|
||
obj.process_code = new_code
|
||
if process_name is not None:
|
||
obj.process_name = (process_name or "").strip()
|
||
if status is not None:
|
||
obj.status = status
|
||
if order_num is not None:
|
||
obj.order_num = order_num
|
||
if remark is not None:
|
||
obj.remark = (remark or "").strip() or None
|
||
obj.update_by = user_id
|
||
obj.update_time = datetime.now()
|
||
db.add(obj)
|
||
db.commit()
|
||
db.refresh(obj)
|
||
return obj
|
||
|
||
|
||
def soft_delete_process_def(db: Session, def_id: str) -> None:
|
||
obj = get_process_def(db, def_id)
|
||
if not obj:
|
||
raise ValueError("流程定义不存在")
|
||
obj.del_flag = 1
|
||
obj.update_time = datetime.now()
|
||
db.add(obj)
|
||
db.commit()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 流程版本 wf_process_version
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def publish_version(
|
||
db: Session,
|
||
process_def_id: str,
|
||
graph_json: str,
|
||
nodes: List[Dict[str, Any]],
|
||
transitions: List[Dict[str, Any]],
|
||
tenant_no: str,
|
||
remark: Optional[str] = None,
|
||
user_id: Optional[str] = None,
|
||
) -> WfProcessVersion:
|
||
defn = get_process_def(db, process_def_id)
|
||
if not defn:
|
||
raise ValueError("流程定义不存在")
|
||
|
||
db.query(WfProcessVersion).filter(
|
||
and_(
|
||
WfProcessVersion.process_def_id == process_def_id,
|
||
WfProcessVersion.is_latest == "1",
|
||
WfProcessVersion.del_flag == 0,
|
||
)
|
||
).update({"is_latest": "0", "update_time": datetime.now()}, synchronize_session=False)
|
||
|
||
max_ver = (
|
||
db.query(func.max(WfProcessVersion.version_no))
|
||
.filter(and_(WfProcessVersion.process_def_id == process_def_id, WfProcessVersion.del_flag == 0))
|
||
.scalar()
|
||
) or 0
|
||
new_ver_no = max_ver + 1
|
||
|
||
ver = WfProcessVersion(
|
||
id=generate_uuid(),
|
||
process_def_id=process_def_id,
|
||
version_no=new_ver_no,
|
||
graph_json=graph_json,
|
||
is_latest="1",
|
||
tenant_no=tenant_no,
|
||
order_num=0,
|
||
remark=(remark or "").strip() or None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(ver)
|
||
db.flush()
|
||
|
||
for idx, n in enumerate(nodes):
|
||
node = WfNode(
|
||
id=generate_uuid(),
|
||
process_version_id=ver.id,
|
||
node_key=n.get("nodeKey", ""),
|
||
node_type=n.get("nodeType", ""),
|
||
node_name=n.get("nodeName"),
|
||
config_json=n.get("configJson"),
|
||
tenant_no=tenant_no,
|
||
order_num=idx,
|
||
remark=None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(node)
|
||
|
||
for idx, t in enumerate(transitions):
|
||
trans = WfTransition(
|
||
id=generate_uuid(),
|
||
process_version_id=ver.id,
|
||
from_node_key=t.get("fromNodeKey", ""),
|
||
to_node_key=t.get("toNodeKey", ""),
|
||
condition_expr=t.get("conditionExpr"),
|
||
tenant_no=tenant_no,
|
||
order_num=idx,
|
||
remark=None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(trans)
|
||
|
||
db.commit()
|
||
db.refresh(ver)
|
||
return ver
|
||
|
||
|
||
def get_latest_version(db: Session, process_def_id: str) -> Optional[WfProcessVersion]:
|
||
return (
|
||
db.query(WfProcessVersion)
|
||
.filter(
|
||
and_(
|
||
WfProcessVersion.process_def_id == process_def_id,
|
||
WfProcessVersion.is_latest == "1",
|
||
WfProcessVersion.del_flag == 0,
|
||
)
|
||
)
|
||
.first()
|
||
)
|
||
|
||
|
||
def _version_to_dict(v: WfProcessVersion) -> Dict[str, Any]:
|
||
return {
|
||
"id": v.id,
|
||
"versionNo": v.version_no,
|
||
"isLatest": v.is_latest,
|
||
"remark": v.remark or "",
|
||
"createTime": v.create_time.strftime("%Y-%m-%d %H:%M:%S") if v.create_time else "",
|
||
"updateTime": v.update_time.strftime("%Y-%m-%d %H:%M:%S") if v.update_time else "",
|
||
}
|
||
|
||
|
||
def list_versions(
|
||
db: Session, process_def_id: str, tenant_no: Optional[str] = None, user_info=None
|
||
) -> List[Dict[str, Any]]:
|
||
q = db.query(WfProcessVersion).filter(
|
||
and_(WfProcessVersion.process_def_id == process_def_id, WfProcessVersion.del_flag == 0)
|
||
)
|
||
if tenant_no:
|
||
q = q.filter(WfProcessVersion.tenant_no == tenant_no)
|
||
if user_info:
|
||
from app.core.data_scope import apply_data_scope
|
||
q = apply_data_scope(q, WfProcessVersion, user_info, db, tenant_no)
|
||
rows = q.order_by(WfProcessVersion.version_no.desc()).all()
|
||
return [_version_to_dict(v) for v in rows]
|
||
|
||
|
||
def get_nodes_by_version(db: Session, version_id: str) -> List[WfNode]:
|
||
return (
|
||
db.query(WfNode)
|
||
.filter(and_(WfNode.process_version_id == version_id, WfNode.del_flag == 0))
|
||
.order_by(WfNode.order_num.asc())
|
||
.all()
|
||
)
|
||
|
||
|
||
def get_transitions_by_version(db: Session, version_id: str) -> List[WfTransition]:
|
||
return (
|
||
db.query(WfTransition)
|
||
.filter(and_(WfTransition.process_version_id == version_id, WfTransition.del_flag == 0))
|
||
.order_by(WfTransition.order_num.asc())
|
||
.all()
|
||
)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 流程实例 wf_process_instance
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def create_instance(
|
||
db: Session,
|
||
*,
|
||
process_version_id: str,
|
||
business_type: Optional[str] = None,
|
||
business_id: Optional[str] = None,
|
||
starter_user_id: Optional[str] = None,
|
||
variables: Optional[Dict[str, Any]] = None,
|
||
status: Optional[str] = None,
|
||
callback_url: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_id: Optional[str] = None,
|
||
) -> WfProcessInstance:
|
||
obj = WfProcessInstance(
|
||
id=generate_uuid(),
|
||
process_version_id=process_version_id,
|
||
business_type=business_type,
|
||
business_id=business_id,
|
||
starter_user_id=starter_user_id,
|
||
variables_json=json.dumps(variables, ensure_ascii=False) if variables else None,
|
||
status=status or "running",
|
||
callback_url=callback_url,
|
||
tenant_no=tenant_no or "zkxw",
|
||
order_num=0,
|
||
remark=None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(obj)
|
||
db.commit()
|
||
db.refresh(obj)
|
||
return obj
|
||
|
||
|
||
def get_instance(db: Session, instance_id: str) -> Optional[WfProcessInstance]:
|
||
return (
|
||
db.query(WfProcessInstance)
|
||
.filter(and_(WfProcessInstance.id == instance_id, WfProcessInstance.del_flag == 0))
|
||
.first()
|
||
)
|
||
|
||
|
||
def update_instance_status(db: Session, instance_id: str, status: str) -> None:
|
||
obj = get_instance(db, instance_id)
|
||
if not obj:
|
||
raise ValueError("流程实例不存在")
|
||
obj.status = status
|
||
obj.update_time = datetime.now()
|
||
db.add(obj)
|
||
db.commit()
|
||
|
||
|
||
def list_my_instances(
|
||
db: Session,
|
||
user_id: str,
|
||
*,
|
||
page: int = 1,
|
||
page_size: int = 10,
|
||
keyword: Optional[str] = None,
|
||
status: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_info=None,
|
||
) -> Tuple[List[Dict[str, Any]], int]:
|
||
from sqlalchemy import func as sa_func
|
||
|
||
latest_per_biz = (
|
||
db.query(
|
||
WfProcessInstance.business_id,
|
||
sa_func.max(WfProcessInstance.create_time).label("max_ct"),
|
||
)
|
||
.filter(
|
||
and_(
|
||
WfProcessInstance.starter_user_id == user_id,
|
||
WfProcessInstance.del_flag == 0,
|
||
WfProcessInstance.business_id != None,
|
||
WfProcessInstance.business_id != "",
|
||
)
|
||
)
|
||
.group_by(WfProcessInstance.business_id)
|
||
.subquery()
|
||
)
|
||
|
||
q0 = (
|
||
db.query(WfProcessInstance, WfProcessVersion, WfProcessDef)
|
||
.join(WfProcessVersion, WfProcessInstance.process_version_id == WfProcessVersion.id)
|
||
.join(WfProcessDef, WfProcessVersion.process_def_id == WfProcessDef.id)
|
||
.join(
|
||
latest_per_biz,
|
||
and_(
|
||
WfProcessInstance.business_id == latest_per_biz.c.business_id,
|
||
WfProcessInstance.create_time == latest_per_biz.c.max_ct,
|
||
),
|
||
)
|
||
.filter(
|
||
and_(
|
||
WfProcessInstance.starter_user_id == user_id,
|
||
WfProcessInstance.del_flag == 0,
|
||
WfProcessVersion.del_flag == 0,
|
||
WfProcessDef.del_flag == 0,
|
||
)
|
||
)
|
||
)
|
||
if tenant_no:
|
||
q0 = q0.filter(WfProcessInstance.tenant_no == tenant_no)
|
||
if status:
|
||
q0 = q0.filter(WfProcessInstance.status == status)
|
||
kw = (keyword or "").strip()
|
||
if kw:
|
||
like = f"%{kw}%"
|
||
q0 = q0.filter(
|
||
or_(WfProcessDef.process_name.like(like), WfProcessInstance.business_id.like(like))
|
||
)
|
||
if user_info:
|
||
from app.core.data_scope import apply_data_scope
|
||
q0 = apply_data_scope(q0, WfProcessInstance, user_info, db, tenant_no)
|
||
|
||
total = q0.order_by(None).with_entities(func.count(WfProcessInstance.id)).scalar() or 0
|
||
page = max(1, page)
|
||
page_size = min(max(1, page_size), 100)
|
||
rows = (
|
||
q0.order_by(WfProcessInstance.create_time.desc())
|
||
.offset((page - 1) * page_size)
|
||
.limit(page_size)
|
||
.all()
|
||
)
|
||
result = []
|
||
for inst, ver, defn in rows:
|
||
result.append({
|
||
"id": inst.id,
|
||
"processName": defn.process_name,
|
||
"businessType": inst.business_type,
|
||
"businessId": inst.business_id,
|
||
"starterUserId": inst.starter_user_id,
|
||
"status": inst.status,
|
||
"createTime": inst.create_time.strftime("%Y-%m-%d %H:%M:%S") if inst.create_time else "",
|
||
"updateTime": inst.update_time.strftime("%Y-%m-%d %H:%M:%S") if inst.update_time else "",
|
||
})
|
||
return result, int(total)
|
||
|
||
|
||
def get_all_tasks_for_business(
|
||
db: Session,
|
||
business_type: str,
|
||
business_id: str,
|
||
) -> List[Dict[str, Any]]:
|
||
instances = (
|
||
db.query(WfProcessInstance)
|
||
.filter(
|
||
and_(
|
||
WfProcessInstance.business_type == business_type,
|
||
WfProcessInstance.business_id == business_id,
|
||
WfProcessInstance.del_flag == 0,
|
||
)
|
||
)
|
||
.order_by(WfProcessInstance.create_time.asc())
|
||
.all()
|
||
)
|
||
|
||
all_tasks: List[Dict[str, Any]] = []
|
||
for inst in instances:
|
||
node_name_map: Dict[str, str] = {}
|
||
if inst.process_version_id:
|
||
for n in get_nodes_by_version(db, inst.process_version_id):
|
||
node_name_map[n.node_key] = n.node_name or n.node_key
|
||
|
||
tasks = (
|
||
db.query(WfTask)
|
||
.filter(and_(WfTask.instance_id == inst.id, WfTask.del_flag == 0))
|
||
.order_by(WfTask.create_time.asc())
|
||
.all()
|
||
)
|
||
|
||
user_ids = {t.assignee_user_id for t in tasks if t.assignee_user_id}
|
||
user_name_map: Dict[str, str] = {}
|
||
if user_ids:
|
||
rows = db.query(SysUser.id, SysUser.nick_name).filter(SysUser.id.in_(user_ids)).all()
|
||
user_name_map = {r.id: r.nick_name for r in rows}
|
||
|
||
for t in tasks:
|
||
all_tasks.append({
|
||
"id": t.id,
|
||
"instanceId": inst.id,
|
||
"instanceStatus": inst.status,
|
||
"nodeKey": t.node_key,
|
||
"nodeName": node_name_map.get(t.node_key, t.node_key or ""),
|
||
"assigneeUserId": t.assignee_user_id,
|
||
"assigneeUserName": user_name_map.get(t.assignee_user_id, t.assignee_user_id or ""),
|
||
"status": t.status,
|
||
"commentText": t.comment_text,
|
||
"createTime": t.create_time.strftime("%Y-%m-%d %H:%M:%S") if t.create_time else "",
|
||
"updateTime": t.update_time.strftime("%Y-%m-%d %H:%M:%S") if t.update_time else "",
|
||
})
|
||
|
||
return all_tasks
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 流程任务 wf_task
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def create_task(
|
||
db: Session,
|
||
*,
|
||
instance_id: str,
|
||
node_key: Optional[str] = None,
|
||
assignee_user_id: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_id: Optional[str] = None,
|
||
) -> WfTask:
|
||
obj = WfTask(
|
||
id=generate_uuid(),
|
||
instance_id=instance_id,
|
||
node_key=node_key,
|
||
assignee_user_id=assignee_user_id,
|
||
status="pending",
|
||
tenant_no=tenant_no or "zkxw",
|
||
order_num=0,
|
||
remark=None,
|
||
create_by=user_id,
|
||
create_dept_id="",
|
||
create_time=datetime.now(),
|
||
update_by=user_id,
|
||
update_time=datetime.now(),
|
||
del_flag=0,
|
||
)
|
||
db.add(obj)
|
||
db.commit()
|
||
db.refresh(obj)
|
||
return obj
|
||
|
||
|
||
def get_task(db: Session, task_id: str) -> Optional[WfTask]:
|
||
return (
|
||
db.query(WfTask)
|
||
.filter(and_(WfTask.id == task_id, WfTask.del_flag == 0))
|
||
.first()
|
||
)
|
||
|
||
|
||
def get_pending_tasks_by_node(db: Session, instance_id: str, node_key: str) -> List[WfTask]:
|
||
return (
|
||
db.query(WfTask)
|
||
.filter(
|
||
and_(
|
||
WfTask.instance_id == instance_id,
|
||
WfTask.node_key == node_key,
|
||
WfTask.status == "pending",
|
||
WfTask.del_flag == 0,
|
||
)
|
||
)
|
||
.all()
|
||
)
|
||
|
||
|
||
def _task_row_to_dict(
|
||
t: WfTask,
|
||
process_name: Optional[str] = None,
|
||
business_type: Optional[str] = None,
|
||
business_id: Optional[str] = None,
|
||
starter_user_id: Optional[str] = None,
|
||
instance_status: Optional[str] = None,
|
||
instance_create_time: Optional[str] = None,
|
||
) -> Dict[str, Any]:
|
||
return {
|
||
"id": t.id,
|
||
"instanceId": t.instance_id,
|
||
"nodeKey": t.node_key,
|
||
"assigneeUserId": t.assignee_user_id,
|
||
"status": t.status,
|
||
"commentText": t.comment_text,
|
||
"createTime": t.create_time.strftime("%Y-%m-%d %H:%M:%S") if t.create_time else "",
|
||
"updateTime": t.update_time.strftime("%Y-%m-%d %H:%M:%S") if t.update_time else "",
|
||
"processName": process_name,
|
||
"businessType": business_type,
|
||
"businessId": business_id,
|
||
"starterUserId": starter_user_id,
|
||
"instanceStatus": instance_status,
|
||
"instanceCreateTime": instance_create_time,
|
||
}
|
||
|
||
|
||
def list_pending_tasks(
|
||
db: Session,
|
||
user_id: str,
|
||
*,
|
||
page: int = 1,
|
||
page_size: int = 10,
|
||
keyword: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_info=None,
|
||
) -> Tuple[List[Dict[str, Any]], int]:
|
||
q0 = (
|
||
db.query(WfTask, WfProcessInstance, WfProcessVersion, WfProcessDef)
|
||
.join(WfProcessInstance, WfTask.instance_id == WfProcessInstance.id)
|
||
.join(WfProcessVersion, WfProcessInstance.process_version_id == WfProcessVersion.id)
|
||
.join(WfProcessDef, WfProcessVersion.process_def_id == WfProcessDef.id)
|
||
.filter(
|
||
and_(
|
||
WfTask.assignee_user_id == user_id,
|
||
WfTask.status == "pending",
|
||
WfTask.del_flag == 0,
|
||
WfProcessInstance.del_flag == 0,
|
||
WfProcessVersion.del_flag == 0,
|
||
WfProcessDef.del_flag == 0,
|
||
)
|
||
)
|
||
)
|
||
if tenant_no:
|
||
q0 = q0.filter(WfTask.tenant_no == tenant_no)
|
||
kw = (keyword or "").strip()
|
||
if kw:
|
||
like = f"%{kw}%"
|
||
q0 = q0.filter(
|
||
or_(WfProcessDef.process_name.like(like), WfProcessDef.process_code.like(like))
|
||
)
|
||
if user_info:
|
||
from app.core.data_scope import apply_data_scope
|
||
q0 = apply_data_scope(q0, WfTask, user_info, db, tenant_no)
|
||
|
||
total = q0.order_by(None).with_entities(func.count(WfTask.id)).scalar() or 0
|
||
page = max(1, page)
|
||
page_size = min(max(1, page_size), 100)
|
||
rows = (
|
||
q0.order_by(WfTask.create_time.desc())
|
||
.offset((page - 1) * page_size)
|
||
.limit(page_size)
|
||
.all()
|
||
)
|
||
result = []
|
||
for task, inst, ver, defn in rows:
|
||
result.append(
|
||
_task_row_to_dict(
|
||
task,
|
||
process_name=defn.process_name,
|
||
business_type=inst.business_type,
|
||
business_id=inst.business_id,
|
||
starter_user_id=inst.starter_user_id,
|
||
instance_status=inst.status,
|
||
instance_create_time=inst.create_time.strftime("%Y-%m-%d %H:%M:%S") if inst.create_time else "",
|
||
)
|
||
)
|
||
return result, int(total)
|
||
|
||
|
||
def list_completed_tasks(
|
||
db: Session,
|
||
user_id: str,
|
||
*,
|
||
page: int = 1,
|
||
page_size: int = 10,
|
||
keyword: Optional[str] = None,
|
||
tenant_no: Optional[str] = None,
|
||
user_info=None,
|
||
) -> Tuple[List[Dict[str, Any]], int]:
|
||
q0 = (
|
||
db.query(WfTask, WfProcessInstance, WfProcessVersion, WfProcessDef)
|
||
.join(WfProcessInstance, WfTask.instance_id == WfProcessInstance.id)
|
||
.join(WfProcessVersion, WfProcessInstance.process_version_id == WfProcessVersion.id)
|
||
.join(WfProcessDef, WfProcessVersion.process_def_id == WfProcessDef.id)
|
||
.filter(
|
||
and_(
|
||
WfTask.assignee_user_id == user_id,
|
||
WfTask.status.in_(["approved", "rejected"]),
|
||
WfTask.del_flag == 0,
|
||
WfProcessInstance.del_flag == 0,
|
||
WfProcessVersion.del_flag == 0,
|
||
WfProcessDef.del_flag == 0,
|
||
)
|
||
)
|
||
)
|
||
if tenant_no:
|
||
q0 = q0.filter(WfTask.tenant_no == tenant_no)
|
||
kw = (keyword or "").strip()
|
||
if kw:
|
||
like = f"%{kw}%"
|
||
q0 = q0.filter(
|
||
or_(WfProcessDef.process_name.like(like), WfProcessDef.process_code.like(like))
|
||
)
|
||
if user_info:
|
||
from app.core.data_scope import apply_data_scope
|
||
q0 = apply_data_scope(q0, WfTask, user_info, db, tenant_no)
|
||
|
||
total = q0.order_by(None).with_entities(func.count(WfTask.id)).scalar() or 0
|
||
page = max(1, page)
|
||
page_size = min(max(1, page_size), 100)
|
||
rows = (
|
||
q0.order_by(WfTask.update_time.desc())
|
||
.offset((page - 1) * page_size)
|
||
.limit(page_size)
|
||
.all()
|
||
)
|
||
result = []
|
||
for task, inst, ver, defn in rows:
|
||
result.append(
|
||
_task_row_to_dict(
|
||
task,
|
||
process_name=defn.process_name,
|
||
business_type=inst.business_type,
|
||
business_id=inst.business_id,
|
||
starter_user_id=inst.starter_user_id,
|
||
instance_status=inst.status,
|
||
instance_create_time=inst.create_time.strftime("%Y-%m-%d %H:%M:%S") if inst.create_time else "",
|
||
)
|
||
)
|
||
return result, int(total)
|
||
|
||
|
||
def total_pages(total: int, page_size: int) -> int:
|
||
if total <= 0:
|
||
return 0
|
||
return int(math.ceil(total / float(page_size)))
|