"""OA 审批运行时引擎（钉钉式竖向树）""" from __future__ import annotations import json from datetime import datetime from typing import Any, Dict, List, Optional, Tuple from sqlalchemy.orm import Session from app.core.utils import generate_uuid from app.crud import oa_approval as oa_crud from app.models.models import ( OaApp, OaAppVersion, OaInstance, OaInstanceEvent, OaRelation, OaRole, OaTask, SysUser, ) from app.services.oa_assignee import AssigneeResolveError, resolve_assignees from app.services.oa_formula import FormulaError, apply_formulas_and_linkages, eval_formula class OaEngineError(ValueError): """引擎业务错误""" def _loads(text: Optional[str], default: Any = None) -> Any: if text is None or text == "": return default if not isinstance(text, str): return text try: return json.loads(text) except (TypeError, ValueError): return default def _dumps(data: Any) -> str: return json.dumps(data if data is not None else {}, ensure_ascii=False) def _node_type(node: Dict[str, Any]) -> str: return (node.get("type") or "").strip() def _flow_root(flow_tree: Any) -> Dict[str, Any]: if not isinstance(flow_tree, dict): raise OaEngineError("流程树无效") if isinstance(flow_tree.get("root"), dict): return flow_tree["root"] return flow_tree def _find_node(root: Dict[str, Any], node_key: str) -> Optional[Dict[str, Any]]: if not root or not node_key: return None if (root.get("id") or "") == node_key: return root child = root.get("child") if isinstance(child, dict): found = _find_node(child, node_key) if found: return found for g in root.get("conditionGroups") or []: if isinstance(g, dict) and isinstance(g.get("child"), dict): found = _find_node(g["child"], node_key) if found: return found return None def _flow_node_key_order(root: Dict[str, Any]) -> Dict[str, int]: """按流程树先序遍历为 node.id 分配稳定序号（用于详情时间轴排序）。""" order: Dict[str, int] = {} counter = 0 def walk(node: Any) -> None: nonlocal counter if not isinstance(node, dict): return nid = (node.get("id") or "").strip() if nid and nid not in order: order[nid] = counter counter += 1 if _node_type(node) == "condition": for g in node.get("conditionGroups") or []: if isinstance(g, dict) and isinstance(g.get("child"), dict): walk(g["child"]) child = node.get("child") if isinstance(child, dict): walk(child) walk(root) return order def _next_task_order_num(db: Session, instance_id: str) -> int: """同一实例内任务展示序号取 max+1（无任务从 1 起）。""" rows = ( db.query(OaTask.order_num) .filter(OaTask.instance_id == instance_id, OaTask.del_flag == 0) .all() ) vals = [int(r[0]) for r in rows if r[0] is not None] return (max(vals) + 1) if vals else 1 def _sort_tasks_for_detail( tasks: List[OaTask], *, flow_root: Optional[Dict[str, Any]] ) -> List[OaTask]: """详情时间轴：按流程树节点顺序，再 order_num / create_time（兼容旧数据同秒创建）。""" node_order = _flow_node_key_order(flow_root) if isinstance(flow_root, dict) else {} far = 10**9 def key(t: OaTask) -> Tuple[int, int, int, datetime, str]: nk = (t.node_key or "").strip() return ( int(getattr(t, "round_no", None) or 1), node_order.get(nk, far), int(t.order_num) if t.order_num is not None else 0, t.create_time or datetime.min, t.id or "", ) return sorted(tasks, key=key) def _fmt_dt(dt: Any) -> str: if not dt: return "" if hasattr(dt, "strftime"): return dt.strftime("%Y-%m-%d %H:%M:%S") return str(dt) def _terminal_item(status: str, title: str, inst: Any) -> Dict[str, Any]: return { "kind": "terminal", "roundNo": getattr(inst, "current_round", None) or 1, "title": title, "status": status, "assigneeUserId": "", "assigneeUserName": "", "timestamp": _fmt_dt(getattr(inst, "update_time", None)), "commentText": "", "nodeKey": "", "taskType": "", } def _task_round(t: Any) -> int: v = getattr(t, "round_no", None) try: if v is None: return 1 return int(v) except (TypeError, ValueError): return 1 def _append_pending_nodes( items: List[Dict[str, Any]], *, flow_root: Dict[str, Any], reached_keys: set, round_no: int, ) -> None: order = _flow_node_key_order(flow_root) for nid, _idx in sorted(order.items(), key=lambda x: x[1]): node = _find_node(flow_root, nid) if not node: continue nt = _node_type(node) if nt not in ("approval", "cc") or nid in reached_keys: continue items.append( { "kind": "pending_node", "roundNo": round_no, "title": node.get("name") or ("抄送人" if nt == "cc" else "审批人"), "status": "not_reached", "assigneeUserId": "", "assigneeUserName": "", "timestamp": "", "commentText": "", "nodeKey": nid, "taskType": nt, } ) def build_progress_items( *, inst: Any, flow_root: Optional[Dict[str, Any]], tasks: List[Any], name_map: Dict[str, str], events: Optional[List[Any]] = None, ) -> List[Dict[str, Any]]: """投影审批进度：发起人 → 树序 tasks → 未到达；终态收尾。 钉钉对齐：打回结果落在审批任务节点上，不另插 kind=return；不做同单多轮分段。 """ events = list(events or []) sorted_tasks = _sort_tasks_for_detail(list(tasks), flow_root=flow_root) # 展示压成单轴（roundNo 统一为 1）；历史多轮任务仍按树序合并展示 rn = 1 submit_ts = _fmt_dt(getattr(inst, "create_time", None)) for e in events: if (getattr(e, "event_type", None) or "") == "submit": submit_ts = _fmt_dt(getattr(e, "create_time", None)) or submit_ts break items: List[Dict[str, Any]] = [ { "kind": "submit", "roundNo": rn, "title": "发起人", "status": "submitted", "assigneeUserId": inst.initiator_user_id, "assigneeUserName": name_map.get(inst.initiator_user_id or "", ""), "timestamp": submit_ts, "commentText": "", "nodeKey": "", "taskType": "", } ] reached_keys = { (t.node_key or "").strip() for t in sorted_tasks if (t.node_key or "").strip() } for t in sorted_tasks: items.append( { "kind": "task", "roundNo": rn, "title": t.node_name or t.node_key or "-", "status": t.status, "assigneeUserId": t.assignee_user_id, "assigneeUserName": name_map.get(t.assignee_user_id or "", ""), "timestamp": _fmt_dt(t.update_time or t.create_time), "commentText": t.comment_text or "", "nodeKey": t.node_key or "", "taskType": t.task_type or "", "resolveSource": getattr(t, "resolve_source", None) or "", "taskId": t.id, } ) if inst.status == "running" and isinstance(flow_root, dict): _append_pending_nodes( items, flow_root=flow_root, reached_keys=reached_keys, round_no=rn ) if inst.status == "completed": items.append(_terminal_item("done", "流程结束", inst)) elif inst.status == "rejected": items.append(_terminal_item("rejected", "流程结束（已拒绝）", inst)) elif inst.status == "cancelled": items.append(_terminal_item("cancelled", "已撤销", inst)) elif inst.status == "returned": items.append(_terminal_item("returned", "已打回", inst)) return items def _add_instance_event( db: Session, *, inst: OaInstance, event_type: str, actor_user_id: Optional[str], round_no: int, comment: Optional[str] = None, task_id: Optional[str] = None, node_key: Optional[str] = None, ) -> OaInstanceEvent: now = datetime.now() ev = OaInstanceEvent( id=generate_uuid(), instance_id=inst.id, round_no=round_no, event_type=event_type, actor_user_id=actor_user_id, task_id=task_id, node_key=node_key, comment_text=(comment or "").strip() or None, tenant_no=inst.tenant_no, order_num=0, remark=None, create_by=actor_user_id, create_dept_id=inst.initiator_dept_id or "", create_time=now, update_by=actor_user_id, update_time=now, del_flag=0, ) db.add(ev) return ev def _advanced(ver: OaAppVersion) -> Dict[str, Any]: data = _loads(ver.advanced_settings_json, {}) or {} if not isinstance(data, dict): return dict(oa_crud.DEFAULT_ADVANCED_SETTINGS) merged = dict(oa_crud.DEFAULT_ADVANCED_SETTINGS) merged.update(data) return merged def _check_initiator_scope(app: OaApp, user_id: str) -> None: scope = (app.initiator_scope or "all").strip() if scope == "all": return ids = _loads(app.initiator_user_ids, []) or [] if user_id not in ids: raise OaEngineError("您不在该审批的发起范围内") def _instance_to_dict(inst: OaInstance, *, app_name: str = "") -> Dict[str, Any]: return { "id": inst.id, "appId": inst.app_id, "appVersionId": inst.app_version_id, "appName": app_name, "title": inst.title or "", "initiatorUserId": inst.initiator_user_id, "initiatorDeptId": inst.initiator_dept_id or "", "formDataJson": _loads(inst.form_data_json, {}), "status": inst.status, "sourceInstanceId": getattr(inst, "source_instance_id", None) or "", "currentRound": int(getattr(inst, "current_round", None) or 1), "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 "", } def _task_to_dict(t: OaTask, *, assignee_user_name: str = "") -> Dict[str, Any]: return { "id": t.id, "instanceId": t.instance_id, "nodeKey": t.node_key or "", "nodeName": t.node_name or "", "taskType": t.task_type, "assigneeUserId": t.assignee_user_id, "assigneeUserName": assignee_user_name or t.assignee_user_id or "", "status": t.status, "commentText": t.comment_text or "", "resolveSource": t.resolve_source or "", "signMode": t.sign_mode 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 "", } _INSTANCE_STATUS_NODE_LABEL = { "completed": "已完成", "rejected": "已拒绝", "returned": "已打回", "cancelled": "已撤销", } def _instance_progress_summary( inst: OaInstance, *, app_name: str, initiator_user_name: str, pending_approval_tasks: List[OaTask], name_map: Dict[str, str], ) -> Dict[str, Any]: status = (inst.status or "").strip() apply_time = ( inst.create_time.strftime("%Y-%m-%d %H:%M:%S") if inst.create_time else "" ) if status == "running": node_names: List[str] = [] seen_nodes = set() approver_names: List[str] = [] for t in pending_approval_tasks: nn = (t.node_name or t.node_key or "").strip() if nn and nn not in seen_nodes: seen_nodes.add(nn) node_names.append(nn) uid = (t.assignee_user_id or "").strip() if uid: approver_names.append(name_map.get(uid, uid)) current_node = "、".join(node_names) if node_names else "-" current_approvers = "、".join(approver_names) if approver_names else "-" else: current_node = _INSTANCE_STATUS_NODE_LABEL.get(status, status or "-") current_approvers = "-" return { "appName": app_name or (inst.title or ""), "initiatorUserId": inst.initiator_user_id or "", "initiatorUserName": initiator_user_name or name_map.get(inst.initiator_user_id or "", inst.initiator_user_id or ""), "applyTime": apply_time, "instanceStatus": status, "currentNodeName": current_node, "currentApproverNames": current_approvers, } def _enrich_list_rows( db: Session, *, tenant_no: str, rows: List[Dict[str, Any]], instances: List[OaInstance], ) -> List[Dict[str, Any]]: if not rows: return [] inst_by_id = {i.id: i for i in instances} app_ids = list({i.app_id for i in instances if i.app_id}) apps = ( db.query(OaApp) .filter( OaApp.id.in_(app_ids), OaApp.tenant_no == tenant_no, OaApp.del_flag == 0, ) .all() if app_ids else [] ) app_name_by_id = {a.id: (a.app_name or "") for a in apps} inst_ids = list(inst_by_id.keys()) pending_tasks = ( db.query(OaTask) .filter( OaTask.tenant_no == tenant_no, OaTask.del_flag == 0, OaTask.instance_id.in_(inst_ids), OaTask.task_type == "approval", OaTask.status == "pending", ) .order_by(OaTask.create_time.asc()) .all() if inst_ids else [] ) pending_by_inst: Dict[str, List[OaTask]] = {} for t in pending_tasks: pending_by_inst.setdefault(t.instance_id, []).append(t) user_ids: List[str] = [] for i in instances: if i.initiator_user_id: user_ids.append(i.initiator_user_id) for t in pending_tasks: if t.assignee_user_id: user_ids.append(t.assignee_user_id) name_map = _user_name_map(db, user_ids) out: List[Dict[str, Any]] = [] for row in rows: iid = row.get("instanceId") or row.get("id") inst = inst_by_id.get(iid) if not inst: out.append(row) continue summary = _instance_progress_summary( inst, app_name=app_name_by_id.get(inst.app_id, ""), initiator_user_name=name_map.get(inst.initiator_user_id or "", ""), pending_approval_tasks=pending_by_inst.get(inst.id, []), name_map=name_map, ) merged = dict(row) merged.update(summary) out.append(merged) return out def _user_name_map(db: Session, user_ids: List[str]) -> Dict[str, str]: ids = [uid for uid in {str(u or "").strip() for u in user_ids} if uid] if not ids: return {} rows = db.query(SysUser.id, SysUser.nick_name).filter(SysUser.id.in_(ids)).all() return {r.id: (r.nick_name or r.id) for r in rows} def list_templates(db: Session, *, tenant_no: str, user_id: str) -> List[Dict[str, Any]]: apps = ( db.query(OaApp) .filter(OaApp.tenant_no == tenant_no, OaApp.del_flag == 0, OaApp.status == "1") .order_by(OaApp.order_num.asc(), OaApp.create_time.desc()) .all() ) out: List[Dict[str, Any]] = [] for app in apps: pub = oa_crud._find_latest_published(db, app.id, tenant_no) if not pub: continue try: _check_initiator_scope(app, user_id) except OaEngineError: continue out.append( { "id": app.id, "appName": app.app_name, "groupId": app.group_id or "", "iconUrl": app.icon_url or "", "description": app.description or "", "versionId": pub.id, "versionNo": pub.version_no, } ) return out def get_template_detail( db: Session, *, tenant_no: str, app_id: str, user_id: str ) -> Dict[str, Any]: app = oa_crud.get_app(db, app_id, tenant_no) if not app or app.status != "1": raise OaEngineError("应用不存在或已停用") _check_initiator_scope(app, user_id) pub = oa_crud._find_latest_published(db, app_id, tenant_no) if not pub: raise OaEngineError("应用尚未发布") return { "id": app.id, "appName": app.app_name, "groupId": app.group_id or "", "iconUrl": app.icon_url or "", "description": app.description or "", "versionId": pub.id, "versionNo": pub.version_no, "formSchemaJson": _loads(pub.form_schema_json, {}), "flowTreeJson": _loads(pub.flow_tree_json, {}), "advancedSettingsJson": _advanced(pub), } _ASSIGNEE_TYPE_LABEL = { "users": "指定成员", "oa_roles": "工作流角色", "dept_leader": "发起人部门负责人", "direct_supervisor": "发起人的主管", "initiator_select": "发起人自选", } def _role_name_map(db: Session, tenant_no: str, role_ids: List[str], codes: List[str]) -> List[str]: names: List[str] = [] ids = [str(x).strip() for x in (role_ids or []) if str(x).strip()] code_list = [str(c).strip().upper() for c in (codes or []) if str(c).strip()] if ids: rows = ( db.query(OaRole) .filter(OaRole.tenant_no == tenant_no, OaRole.id.in_(ids), OaRole.del_flag == 0) .all() ) names.extend([(r.role_name or r.role_code or r.id) for r in rows]) if code_list: rows = ( db.query(OaRole) .filter( OaRole.tenant_no == tenant_no, OaRole.role_code.in_(code_list), OaRole.del_flag == 0, ) .all() ) for r in rows: label = r.role_name or r.role_code or r.id if label not in names: names.append(label) return names def _assignee_meta(db: Session, tenant_no: str, cfg: Dict[str, Any]) -> str: assignee_type = (cfg.get("assigneeType") or cfg.get("assignee_type") or "").strip() base = _ASSIGNEE_TYPE_LABEL.get(assignee_type, assignee_type or "未配置审批人") if assignee_type == "oa_roles": names = _role_name_map( db, tenant_no, cfg.get("oaRoleIds") or cfg.get("oa_role_ids") or [], cfg.get("oaRoleCodes") or cfg.get("oa_role_codes") or [], ) if names: return f"{base} · {'/'.join(names)}" return base def _preview_people(db: Session, user_ids: List[str]) -> List[Dict[str, str]]: name_map = _user_name_map(db, user_ids) out: List[Dict[str, str]] = [] for uid in user_ids: out.append({"id": uid, "nickName": name_map.get(uid) or uid}) return out def _walk_preview_nodes( db: Session, *, node: Optional[Dict[str, Any]], tenant_no: str, initiator_user_id: str, initiator_dept_id: Optional[str], advanced: Dict[str, Any], initiator_select_user_ids: Optional[List[str]], steps: List[Dict[str, Any]], ) -> None: cur = node while cur and isinstance(cur, dict): ntype = _node_type(cur) if ntype == "start": people = _preview_people(db, [initiator_user_id] if initiator_user_id else []) steps.append( { "id": cur.get("id") or "", "type": "start", "name": cur.get("name") or "发起人", "signMode": "", "assigneeType": "", "meta": "", "people": people, "resolveError": "", } ) cur = cur.get("child") continue if ntype == "end": steps.append( { "id": cur.get("id") or "", "type": "end", "name": cur.get("name") or "结束", "signMode": "", "assigneeType": "", "meta": "", "people": [], "resolveError": "", } ) break if ntype == "condition": groups = cur.get("conditionGroups") or [] for g in groups: if not isinstance(g, dict): continue steps.append( { "id": f"{cur.get('id') or 'cond'}_{(g.get('name') or '分支')}", "type": "branch", "name": g.get("name") or "条件分支", "signMode": "", "assigneeType": "", "meta": "条件分支（实际路径以提交时表单为准）", "people": [], "resolveError": "", } ) child = g.get("child") if isinstance(child, dict): _walk_preview_nodes( db, node=child, tenant_no=tenant_no, initiator_user_id=initiator_user_id, initiator_dept_id=initiator_dept_id, advanced=advanced, initiator_select_user_ids=initiator_select_user_ids, steps=steps, ) cur = cur.get("child") continue if ntype in ("approval", "cc"): cfg = cur.get("approverConfig") or {} assignee_type = (cfg.get("assigneeType") or cfg.get("assignee_type") or "").strip() sign_mode = (cfg.get("signMode") or cfg.get("sign_mode") or "").strip() if ntype == "cc": sign_mode = "cc" elif not sign_mode and assignee_type != "initiator_select": sign_mode = "or" meta = _assignee_meta(db, tenant_no, cfg) people: List[Dict[str, str]] = [] resolve_error = "" if assignee_type == "initiator_select": ids = initiator_select_user_ids or [] people = _preview_people(db, [str(x) for x in ids if str(x).strip()]) if not people: meta = meta or "发起人自选" else: try: assignees, _meta = resolve_assignees( db, tenant_no=tenant_no, assignee_config=cfg, initiator_user_id=initiator_user_id, initiator_dept_id=initiator_dept_id, advanced=advanced, initiator_select_user_ids=initiator_select_user_ids, ) people = _preview_people(db, assignees) except AssigneeResolveError as e: resolve_error = str(e) steps.append( { "id": cur.get("id") or "", "type": ntype, "name": cur.get("name") or ("抄送人" if ntype == "cc" else "审批人"), "signMode": sign_mode, "assigneeType": assignee_type, "meta": meta, "people": people, "resolveError": resolve_error, } ) cur = cur.get("child") continue cur = cur.get("child") def preview_start_flow( db: Session, *, tenant_no: str, app_id: str, initiator_user_id: str, initiator_dept_id: Optional[str] = None, initiator_select_user_ids: Optional[List[str]] = None, ) -> Dict[str, Any]: """发起前预览审批链（解析具体人员；条件分支展开展示）。""" app = oa_crud.get_app(db, app_id, tenant_no) if not app or app.status != "1": raise OaEngineError("应用不存在或已停用") _check_initiator_scope(app, initiator_user_id) pub = oa_crud._find_latest_published(db, app_id, tenant_no) if not pub: raise OaEngineError("应用尚未发布") initiator = ( db.query(SysUser) .filter( SysUser.id == initiator_user_id, SysUser.tenant_no == tenant_no, SysUser.del_flag == 0, ) .first() ) dept_id = (initiator_dept_id or "").strip() or ( (initiator.dept_id or "") if initiator else "" ) flow = _loads(pub.flow_tree_json, {}) or {} root = flow.get("root") if isinstance(flow, dict) else None if not isinstance(root, dict): root = flow if isinstance(flow, dict) else {} steps: List[Dict[str, Any]] = [] _walk_preview_nodes( db, node=root, tenant_no=tenant_no, initiator_user_id=initiator_user_id, initiator_dept_id=dept_id or None, advanced=_advanced(pub), initiator_select_user_ids=initiator_select_user_ids, steps=steps, ) return {"steps": steps} def _create_tasks_for_node( db: Session, *, inst: OaInstance, node: Dict[str, Any], ver: OaAppVersion, user_id: Optional[str], initiator_select_user_ids: Optional[List[str]] = None, order_num_start: Optional[int] = None, ) -> List[OaTask]: ntype = _node_type(node) now = datetime.now() created: List[OaTask] = [] if ntype == "cc": task_type = "cc" elif ntype == "approval": task_type = "approval" else: return created cfg = node.get("approverConfig") or {} advanced = _advanced(ver) try: assignees, meta = resolve_assignees( db, tenant_no=inst.tenant_no, assignee_config=cfg, initiator_user_id=inst.initiator_user_id, initiator_dept_id=inst.initiator_dept_id, advanced=advanced, initiator_select_user_ids=initiator_select_user_ids, ) except AssigneeResolveError as e: raise OaEngineError(str(e)) from e sign_mode = (cfg.get("signMode") or cfg.get("sign_mode") or "or").strip() or "or" resolve_source = meta.get("resolve_source") status = "done" if task_type == "cc" else "pending" seq = order_num_start if order_num_start is not None else _next_task_order_num(db, inst.id) for uid in assignees: t = OaTask( id=generate_uuid(), instance_id=inst.id, node_key=node.get("id") or "", node_name=node.get("name") or "", task_type=task_type, assignee_user_id=uid, status=status, comment_text=None, resolve_source=resolve_source, sign_mode=sign_mode if task_type == "approval" else None, round_no=int(getattr(inst, "current_round", None) or 1), tenant_no=inst.tenant_no, order_num=seq, remark=None, create_by=user_id, create_dept_id=inst.initiator_dept_id or "", create_time=now, update_by=user_id, update_time=now, del_flag=0, ) seq += 1 db.add(t) created.append(t) return created def _match_condition_group(groups: List[Any], form_data: Dict[str, Any]) -> Optional[Dict[str, Any]]: default_g = None for g in groups: if not isinstance(g, dict): continue rules = g.get("rules") when = g.get("when") # 空规则 = 默认分支 if (not rules and not when) or g.get("isDefault"): default_g = g continue expr = when if not expr and isinstance(rules, str): expr = rules if not expr and isinstance(rules, list) and rules: # 简化：每条 {field, op, value} 用 AND parts = [] for r in rules: if not isinstance(r, dict): continue field = r.get("field") op = r.get("op") or "==" val = r.get("value") if field is None: continue if isinstance(val, str): parts.append(f"{{{field}}} {op} '{val}'") else: parts.append(f"{{{field}}} {op} {val}") expr = " and ".join(parts) if parts else None if not expr: default_g = g continue try: if eval_formula(str(expr), form_data): return g except FormulaError: continue return default_g def advance_from( db: Session, *, inst: OaInstance, ver: OaAppVersion, from_node: Optional[Dict[str, Any]], user_id: Optional[str], initiator_select_user_ids: Optional[List[str]] = None, ) -> None: """从某节点的下一跳开始推进；from_node 为 None 表示从 start 进入。""" root = _flow_root(_loads(ver.flow_tree_json, {})) form_data = _loads(inst.form_data_json, {}) or {} def next_node(node: Dict[str, Any]) -> Optional[Dict[str, Any]]: ntype = _node_type(node) if ntype == "condition": groups = node.get("conditionGroups") or [] g = _match_condition_group(groups, form_data) if not g or not isinstance(g.get("child"), dict): raise OaEngineError("条件分支无法匹配出线") return g["child"] child = node.get("child") return child if isinstance(child, dict) else None # 起点 if from_node is None: cur = next_node(root) if _node_type(root) == "start" else root else: cur = next_node(from_node) # 同一次推进里可能连续落抄送+审批：共用递增序号，避免 create_time 同秒时乱序 next_order = _next_task_order_num(db, inst.id) safety = 0 while cur and safety < 50: safety += 1 ntype = _node_type(cur) if ntype == "end": inst.status = "completed" inst.update_time = datetime.now() db.add(inst) return if ntype == "condition": cur = next_node(cur) continue if ntype in ("approval", "cc"): tasks = _create_tasks_for_node( db, inst=inst, node=cur, ver=ver, user_id=user_id, initiator_select_user_ids=initiator_select_user_ids, order_num_start=next_order, ) next_order += max(len(tasks), 1) if ntype == "cc": # 抄送不阻断，继续往下 cur = next_node(cur) continue if not tasks: raise OaEngineError("审批节点未生成任务") return # 未知类型跳过子节点 cur = next_node(cur) # 无结束也无待办：异常结束 if inst.status == "running": raise OaEngineError("流程推进异常：未到达结束且无待办任务") def start_instance( db: Session, *, tenant_no: str, app_id: str, initiator_user_id: str, initiator_dept_id: Optional[str] = None, form_data: Optional[Dict[str, Any]] = None, title: Optional[str] = None, initiator_select_user_ids: Optional[List[str]] = None, related_instance_ids: Optional[List[str]] = None, source_instance_id: Optional[str] = None, ) -> Dict[str, Any]: # source_instance_id 保留入参兼容，不再写入关联（复制开新单不挂旧单） _ = source_instance_id app = oa_crud.get_app(db, app_id, tenant_no) if not app or app.status != "1": raise OaEngineError("应用不存在或已停用") _check_initiator_scope(app, initiator_user_id) ver = oa_crud._find_latest_published(db, app_id, tenant_no) if not ver: raise OaEngineError("应用尚未发布，无法发起") schema = _loads(ver.form_schema_json, {}) data = dict(form_data or {}) try: data = apply_formulas_and_linkages(schema, data) except FormulaError as e: raise OaEngineError(f"公式计算失败: {e}") from e user = ( db.query(SysUser) .filter(SysUser.id == initiator_user_id, SysUser.del_flag == 0) .first() ) dept_id = (initiator_dept_id or (user.dept_id if user else "") or "").strip() or None now = datetime.now() title_text = (title or app.app_name or "").strip() inst = OaInstance( id=generate_uuid(), app_id=app_id, app_version_id=ver.id, title=title_text[:200], initiator_user_id=initiator_user_id, initiator_dept_id=dept_id, form_data_json=_dumps(data), status="running", source_instance_id=None, current_round=1, tenant_no=tenant_no, order_num=0, remark=None, create_by=initiator_user_id, create_dept_id=dept_id or "", create_time=now, update_by=initiator_user_id, update_time=now, del_flag=0, ) db.add(inst) for to_id in related_instance_ids or []: to_id = (to_id or "").strip() if not to_id: continue db.add( OaRelation( id=generate_uuid(), from_instance_id=inst.id, to_instance_id=to_id, field_key=None, tenant_no=tenant_no, order_num=0, remark=None, create_by=initiator_user_id, create_dept_id=dept_id or "", create_time=now, update_by=initiator_user_id, update_time=now, del_flag=0, ) ) _add_instance_event( db, inst=inst, event_type="submit", actor_user_id=initiator_user_id, round_no=1, ) advance_from( db, inst=inst, ver=ver, from_node=None, user_id=initiator_user_id, initiator_select_user_ids=initiator_select_user_ids, ) db.commit() db.refresh(inst) return get_instance_detail(db, inst.id, tenant_no=tenant_no) def _get_instance(db: Session, instance_id: str, tenant_no: str) -> OaInstance: inst = ( db.query(OaInstance) .filter(OaInstance.id == instance_id, OaInstance.tenant_no == tenant_no, OaInstance.del_flag == 0) .first() ) if not inst: raise OaEngineError("实例不存在") return inst def get_instance_detail(db: Session, instance_id: str, *, tenant_no: str) -> Dict[str, Any]: inst = _get_instance(db, instance_id, tenant_no) app = oa_crud.get_app(db, inst.app_id, tenant_no) ver = ( db.query(OaAppVersion) .filter(OaAppVersion.id == inst.app_version_id, OaAppVersion.del_flag == 0) .first() ) tasks = ( db.query(OaTask) .filter(OaTask.instance_id == instance_id, OaTask.del_flag == 0) .all() ) flow_root = None if ver: try: flow_root = _flow_root(_loads(ver.flow_tree_json, {})) except OaEngineError: flow_root = None tasks = _sort_tasks_for_detail(tasks, flow_root=flow_root) rels = ( db.query(OaRelation) .filter(OaRelation.from_instance_id == instance_id, OaRelation.del_flag == 0) .all() ) name_map = _user_name_map( db, [t.assignee_user_id for t in tasks if t.assignee_user_id] + ([inst.initiator_user_id] if inst.initiator_user_id else []), ) data = _instance_to_dict(inst, app_name=app.app_name if app else "") data["initiatorUserName"] = name_map.get(inst.initiator_user_id or "", inst.initiator_user_id or "") data["tasks"] = [ _task_to_dict(t, assignee_user_name=name_map.get(t.assignee_user_id or "", "")) for t in tasks ] data["relatedInstanceIds"] = [r.to_instance_id for r in rels] data["formSchemaJson"] = _loads(ver.form_schema_json, {}) if ver else {} adv = _advanced(ver) if ver else dict(oa_crud.DEFAULT_ADVANCED_SETTINGS) data["advancedSettingsJson"] = adv data["allowAddSign"] = bool(adv.get("allowAddSign", True)) data["allowReturn"] = bool(adv.get("allowReturn", True)) events = ( db.query(OaInstanceEvent) .filter(OaInstanceEvent.instance_id == instance_id, OaInstanceEvent.del_flag == 0) .order_by(OaInstanceEvent.create_time.asc()) .all() ) event_actors = [e.actor_user_id for e in events if e.actor_user_id] if event_actors: name_map.update(_user_name_map(db, event_actors)) data["progress"] = build_progress_items( inst=inst, flow_root=flow_root, tasks=tasks, name_map=name_map, events=events, ) # 不再暴露旧单/重提单关联跳转 data["sourceInstanceId"] = "" data["resubmittedInstanceId"] = "" return data def list_tasks( db: Session, *, tenant_no: str, user_id: str, kind: str, ) -> List[Dict[str, Any]]: kind = (kind or "").strip() if kind == "pending": q = db.query(OaTask).filter( OaTask.tenant_no == tenant_no, OaTask.del_flag == 0, OaTask.assignee_user_id == user_id, OaTask.task_type == "approval", OaTask.status == "pending", ) elif kind == "done": q = db.query(OaTask).filter( OaTask.tenant_no == tenant_no, OaTask.del_flag == 0, OaTask.assignee_user_id == user_id, OaTask.task_type == "approval", OaTask.status.in_(("approved", "rejected", "returned")), ) elif kind == "cc": q = db.query(OaTask).filter( OaTask.tenant_no == tenant_no, OaTask.del_flag == 0, OaTask.assignee_user_id == user_id, OaTask.task_type == "cc", ) elif kind == "mine": insts = ( db.query(OaInstance) .filter( OaInstance.tenant_no == tenant_no, OaInstance.del_flag == 0, OaInstance.initiator_user_id == user_id, ) .order_by(OaInstance.create_time.desc()) .all() ) rows = [_instance_to_dict(i) for i in insts] return _enrich_list_rows(db, tenant_no=tenant_no, rows=rows, instances=insts) else: raise OaEngineError(f"不支持的列表类型: {kind}") rows_orm = q.order_by(OaTask.create_time.desc()).all() rows = [_task_to_dict(t) for t in rows_orm] inst_ids = list({t.instance_id for t in rows_orm if t.instance_id}) insts = ( db.query(OaInstance) .filter( OaInstance.tenant_no == tenant_no, OaInstance.del_flag == 0, OaInstance.id.in_(inst_ids), ) .all() if inst_ids else [] ) return _enrich_list_rows(db, tenant_no=tenant_no, rows=rows, instances=insts) def complete_task( db: Session, task_id: str, *, tenant_no: str, user_id: str, action: str, comment: Optional[str] = None, ) -> Dict[str, Any]: action = (action or "").strip() if action not in ("approve", "reject"): raise OaEngineError("不支持的操作") task = ( db.query(OaTask) .filter(OaTask.id == task_id, OaTask.tenant_no == tenant_no, OaTask.del_flag == 0) .first() ) if not task: raise OaEngineError("任务不存在") if task.assignee_user_id != user_id: raise OaEngineError("无权处理该任务") if task.task_type != "approval" or task.status != "pending": raise OaEngineError("任务状态不可处理") inst = _get_instance(db, task.instance_id, tenant_no) if inst.status != "running": raise OaEngineError("实例已结束") ver = ( db.query(OaAppVersion) .filter(OaAppVersion.id == inst.app_version_id, OaAppVersion.del_flag == 0) .first() ) if not ver: raise OaEngineError("流程版本不存在") advanced = _advanced(ver) if advanced.get("commentRequired") and not (comment or "").strip(): raise OaEngineError("请填写审批意见") now = datetime.now() task.comment_text = (comment or "").strip() or None task.status = "approved" if action == "approve" else "rejected" task.update_by = user_id task.update_time = now db.add(task) # Session 默认 autoflush=False：不先 flush 时，后续按 status=pending 的查询仍会命中本任务， # 或签「取消同节点其余待办」会把本人已同意/已拒绝覆盖成 done，导致「已处理」列表查不到。 db.flush() if action == "reject": # 同节点其他待办作废（排除当前任务） siblings = ( db.query(OaTask) .filter( OaTask.instance_id == inst.id, OaTask.node_key == task.node_key, OaTask.id != task.id, OaTask.status == "pending", OaTask.del_flag == 0, ) .all() ) for s in siblings: s.status = "done" s.update_by = user_id s.update_time = now db.add(s) inst.status = "rejected" inst.update_by = user_id inst.update_time = now db.add(inst) db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no) # 或签：一人通过即可；会签：全部通过 sign_mode = (task.sign_mode or "or").strip() or "or" pending_same = ( db.query(OaTask) .filter( OaTask.instance_id == inst.id, OaTask.node_key == task.node_key, OaTask.task_type == "approval", OaTask.id != task.id, OaTask.status == "pending", OaTask.del_flag == 0, ) .count() ) if sign_mode == "and" and pending_same > 0: db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no) # 或签：取消同节点其余待办（排除当前任务） if sign_mode != "and": for s in ( db.query(OaTask) .filter( OaTask.instance_id == inst.id, OaTask.node_key == task.node_key, OaTask.id != task.id, OaTask.status == "pending", OaTask.del_flag == 0, ) .all() ): s.status = "done" s.update_by = user_id s.update_time = now db.add(s) root = _flow_root(_loads(ver.flow_tree_json, {})) node = _find_node(root, task.node_key or "") if not node: raise OaEngineError("找不到对应流程节点") advance_from(db, inst=inst, ver=ver, from_node=node, user_id=user_id) db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no) def add_sign( db: Session, task_id: str, *, tenant_no: str, user_id: str, user_ids: List[str], comment: Optional[str] = None, ) -> Dict[str, Any]: """当前待办处理人加签：为同节点新增待办审批人。""" task = ( db.query(OaTask) .filter(OaTask.id == task_id, OaTask.tenant_no == tenant_no, OaTask.del_flag == 0) .first() ) if not task: raise OaEngineError("任务不存在") if task.assignee_user_id != user_id: raise OaEngineError("无权加签该任务") if task.task_type != "approval" or task.status != "pending": raise OaEngineError("仅待处理的审批任务可加签") inst = _get_instance(db, task.instance_id, tenant_no) if inst.status != "running": raise OaEngineError("实例已结束") ver = ( db.query(OaAppVersion) .filter(OaAppVersion.id == inst.app_version_id, OaAppVersion.del_flag == 0) .first() ) if not ver: raise OaEngineError("流程版本不存在") advanced = _advanced(ver) if not advanced.get("allowAddSign", True): raise OaEngineError("该应用不允许加签") ids = [] seen = set() for uid in user_ids or []: uid = (uid or "").strip() if not uid or uid in seen: continue seen.add(uid) ids.append(uid) if not ids: raise OaEngineError("请选择加签人") existing = { r.assignee_user_id for r in db.query(OaTask) .filter( OaTask.instance_id == inst.id, OaTask.node_key == task.node_key, OaTask.del_flag == 0, OaTask.status == "pending", ) .all() } now = datetime.now() created = 0 next_order = _next_task_order_num(db, inst.id) for uid in ids: if uid in existing: continue # 校验用户有效 u = ( db.query(SysUser) .filter( SysUser.id == uid, SysUser.tenant_no == tenant_no, SysUser.del_flag == 0, SysUser.status == "1", ) .first() ) if not u: raise OaEngineError(f"加签用户无效：{uid}") db.add( OaTask( id=generate_uuid(), instance_id=inst.id, node_key=task.node_key, node_name=task.node_name, task_type="approval", assignee_user_id=uid, status="pending", comment_text=None, resolve_source="add_sign", sign_mode=task.sign_mode or "or", round_no=int(getattr(inst, "current_round", None) or getattr(task, "round_no", None) or 1), tenant_no=tenant_no, order_num=next_order, remark=(comment or "").strip() or None, create_by=user_id, create_dept_id=inst.initiator_dept_id or "", create_time=now, update_by=user_id, update_time=now, del_flag=0, ) ) next_order += 1 created += 1 if created == 0: raise OaEngineError("所选用户已在当前节点待办中") # 加签后默认按会签语义收口更稳妥：保留原 sign_mode；若原或签则一人通过仍可结束 if comment: task.comment_text = ((task.comment_text or "") + f"\n[加签说明] {comment}").strip() task.update_by = user_id task.update_time = now db.add(task) db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no) def return_task( db: Session, task_id: str, *, tenant_no: str, user_id: str, comment: Optional[str] = None, ) -> Dict[str, Any]: """审批人打回：本单终态 returned；再办须复制表单开新实例。""" task = ( db.query(OaTask) .filter(OaTask.id == task_id, OaTask.tenant_no == tenant_no, OaTask.del_flag == 0) .first() ) if not task: raise OaEngineError("任务不存在") if task.assignee_user_id != user_id: raise OaEngineError("无权打回该任务") if task.task_type != "approval" or task.status != "pending": raise OaEngineError("仅待处理的审批任务可打回") inst = _get_instance(db, task.instance_id, tenant_no) if inst.status != "running": raise OaEngineError("仅进行中的审批可打回") ver = ( db.query(OaAppVersion) .filter(OaAppVersion.id == inst.app_version_id, OaAppVersion.del_flag == 0) .first() ) if not ver: raise OaEngineError("流程版本不存在") advanced = _advanced(ver) if not advanced.get("allowReturn", True): raise OaEngineError("该应用不允许打回") comment_text = (comment or "").strip() if not comment_text: raise OaEngineError("打回意见必填") now = datetime.now() round_no = int(getattr(inst, "current_round", None) or getattr(task, "round_no", None) or 1) task.status = "returned" task.comment_text = comment_text task.update_by = user_id task.update_time = now db.add(task) for t in ( db.query(OaTask) .filter( OaTask.instance_id == inst.id, OaTask.status == "pending", OaTask.del_flag == 0, OaTask.id != task.id, ) .all() ): t.status = "cancelled" t.update_by = user_id t.update_time = now db.add(t) inst.status = "returned" inst.update_by = user_id inst.update_time = now db.add(inst) _add_instance_event( db, inst=inst, event_type="return", actor_user_id=user_id, round_no=round_no, comment=comment_text, task_id=task.id, node_key=task.node_key, ) db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no) def resubmit_instance( db: Session, instance_id: str, *, tenant_no: str, user_id: str, form_data: Optional[Dict[str, Any]] = None, initiator_select_user_ids: Optional[List[str]] = None, ) -> Dict[str, Any]: """已废弃：同实例再次提交。请复制表单重新发起新实例。""" _ = (db, instance_id, tenant_no, user_id, form_data, initiator_select_user_ids) raise OaEngineError("同实例再次提交已废弃，请复制表单重新发起") def withdraw_instance( db: Session, instance_id: str, *, tenant_no: str, user_id: str ) -> Dict[str, Any]: inst = _get_instance(db, instance_id, tenant_no) if inst.initiator_user_id != user_id: raise OaEngineError("仅发起人可撤销") if inst.status != "running": raise OaEngineError("仅运行中的实例可撤销") ver = ( db.query(OaAppVersion) .filter(OaAppVersion.id == inst.app_version_id, OaAppVersion.del_flag == 0) .first() ) advanced = _advanced(ver) if ver else dict(oa_crud.DEFAULT_ADVANCED_SETTINGS) if not advanced.get("allowWithdrawRunning", True): raise OaEngineError("该应用不允许撤销进行中的审批") now = datetime.now() inst.status = "cancelled" inst.update_by = user_id inst.update_time = now db.add(inst) for t in ( db.query(OaTask) .filter(OaTask.instance_id == inst.id, OaTask.status == "pending", OaTask.del_flag == 0) .all() ): t.status = "cancelled" t.update_by = user_id t.update_time = now db.add(t) _add_instance_event( db, inst=inst, event_type="withdraw", actor_user_id=user_id, round_no=int(getattr(inst, "current_round", None) or 1), ) db.commit() return get_instance_detail(db, inst.id, tenant_no=tenant_no)