This commit is contained in:
zlwu committed 2026-06-25 12:41:07 +08:00
1 parent 66609c0e21
commit 0b50eff3d8
93 files changed
+40172 -30060

No files matched your search

@@ -0,0 +1,7 @@
-- 生产过程派发质检:支持仅关联步骤产出物(无细胞产品时也可派发)
ALTER TABLE `biz_qc_work_order`
ADD COLUMN `production_step_output_id` varchar(64) DEFAULT NULL
COMMENT '关联生产任务步骤产出物ID(生产过程触发时)'
AFTER `production_task_id`;
CREATE INDEX `idx_qc_wo_prod_step_output` ON `biz_qc_work_order` (`production_step_output_id`, `del_flag`);
@@ -0,0 +1,30 @@
-- 可选:将仍有 task.current_assignee_user_id 且无步骤负责人的旧任务回填到全部步骤
--
-- 注意:MySQL 5.7 在 INSERT...SELECT 中 UUID() 可能整批只计算一次,导致主键重复。
-- 此处用 SHA2(step_id) 生成确定性主键,每步唯一,且可重复执行(已存在则跳过)。
INSERT INTO `biz_production_task_step_assignee` (
`id`, `step_id`, `user_id`, `tenant_no`, `order_num`,
`create_by`, `create_dept_id`, `create_time`, `update_by`, `update_time`, `del_flag`
)
SELECT
LOWER(SHA2(CONCAT('step-assignee-backfill:', s.id), 256)),
s.id,
t.current_assignee_user_id,
s.tenant_no,
0,
t.create_by,
IFNULL(t.create_dept_id, ''),
NOW(),
t.update_by,
NOW(),
0
FROM `biz_production_task` t
JOIN `biz_production_task_step` s ON s.task_id = t.id AND s.del_flag = 0
WHERE t.del_flag = 0
AND t.current_assignee_user_id IS NOT NULL
AND TRIM(t.current_assignee_user_id) <> ''
AND NOT EXISTS (
SELECT 1 FROM `biz_production_task_step_assignee` a
WHERE a.step_id = s.id AND a.del_flag = 0
);
@@ -0,0 +1,26 @@
-- 生产任务 · 工艺步骤级派发
-- 步骤计划开始时间、完成人 + 步骤负责人关联表
ALTER TABLE `biz_production_task_step`
ADD COLUMN `planned_start_time` datetime DEFAULT NULL COMMENT '计划开始时间' AFTER `step_status`;
ALTER TABLE `biz_production_task_step`
ADD COLUMN `completed_by` varchar(64) DEFAULT NULL COMMENT '完成步骤的用户ID' AFTER `completed_time`;
CREATE TABLE IF NOT EXISTS `biz_production_task_step_assignee` (
`id` varchar(64) NOT NULL COMMENT '主键',
`step_id` varchar(64) NOT NULL COMMENT '生产任务步骤ID',
`user_id` varchar(64) NOT NULL COMMENT '负责人用户ID',
`tenant_no` varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
`order_num` int DEFAULT 0 COMMENT '展示顺序',
`remark` varchar(512) DEFAULT NULL COMMENT '备注',
`create_by` varchar(64) DEFAULT NULL COMMENT '创建人id',
`create_dept_id` varchar(64) NOT NULL DEFAULT '' COMMENT '创建人部门ID',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_by` varchar(64) DEFAULT NULL COMMENT '更新人id',
`update_time` datetime NOT NULL COMMENT '更新时间',
`del_flag` tinyint NOT NULL DEFAULT 0 COMMENT '删除标记',
PRIMARY KEY (`id`),
KEY `idx_step_assignee_step` (`step_id`),
KEY `idx_step_assignee_user` (`user_id`, `tenant_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='生产任务步骤负责人';
+33 -1
View File
@@ -3522,8 +3522,10 @@ CREATE TABLE `biz_production_task_step` (
`actual_duration` varchar(100) DEFAULT NULL COMMENT '实际耗时',
`sop_ids` varchar(1000) DEFAULT NULL COMMENT 'SOP文档ID(逗号分隔)',
`step_status` varchar(16) NOT NULL DEFAULT 'dzx' COMMENT '状态(dzx待执行/jxz进行中/ywc已完成)',
`planned_start_time` datetime DEFAULT NULL COMMENT '计划开始时间',
`started_time` datetime DEFAULT NULL COMMENT '开始时间',
`completed_time` datetime DEFAULT NULL COMMENT '完成时间',
`completed_by` varchar(64) DEFAULT NULL COMMENT '完成步骤的用户ID',
`tenant_no` varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
`order_num` int(11) DEFAULT NULL COMMENT '排序号',
`remark` varchar(512) DEFAULT NULL COMMENT '备注',
@@ -3538,12 +3540,40 @@ CREATE TABLE `biz_production_task_step` (
KEY `idx_pts_tenant` (`tenant_no`,`del_flag`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='生产任务工艺步骤';
-- ----------------------------
-- Table structure for biz_production_task_step_assignee
-- ----------------------------
DROP TABLE IF EXISTS `biz_production_task_step_assignee`;
CREATE TABLE `biz_production_task_step_assignee` (
`id` varchar(64) NOT NULL COMMENT '主键',
`step_id` varchar(64) NOT NULL COMMENT '生产任务步骤ID',
`user_id` varchar(64) NOT NULL COMMENT '负责人用户ID',
`tenant_no` varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
`order_num` int(11) DEFAULT '0' COMMENT '展示顺序',
`remark` varchar(512) DEFAULT NULL COMMENT '备注',
`create_by` varchar(64) DEFAULT NULL COMMENT '创建人id',
`create_dept_id` varchar(64) NOT NULL DEFAULT '' COMMENT '创建人部门ID',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_by` varchar(64) DEFAULT NULL COMMENT '更新人id',
`update_time` datetime NOT NULL COMMENT '更新时间',
`del_flag` tinyint(4) NOT NULL DEFAULT '0' COMMENT '删除标记:0-正常 1-已删除',
PRIMARY KEY (`id`),
KEY `idx_step_assignee_step` (`step_id`),
KEY `idx_step_assignee_user` (`user_id`,`tenant_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='生产任务步骤负责人';
-- ----------------------------
-- Records of biz_production_task_step
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Records of biz_production_task_step_assignee
-- ----------------------------
BEGIN;
COMMIT;
-- ----------------------------
-- Table structure for biz_production_task_step_configured_reagent
-- ----------------------------
@@ -4647,6 +4677,7 @@ CREATE TABLE `biz_qc_work_order` (
`cell_product_id` varchar(64) DEFAULT NULL COMMENT '质检对象-细胞产品ID',
`production_work_order_id` varchar(64) DEFAULT NULL COMMENT '关联生产工单ID(生产过程触发时)',
`production_task_id` varchar(64) DEFAULT NULL COMMENT '关联生产任务ID(可选)',
`production_step_output_id` varchar(64) DEFAULT NULL COMMENT '关联生产任务步骤产出物ID(生产过程触发时)',
`work_order_status` varchar(16) NOT NULL DEFAULT 'dpz' COMMENT 'dpz待配置 ypz已配置 ywc已完成',
`has_lab` char(1) NOT NULL DEFAULT '0' COMMENT '含实验室自检',
`has_third_party` char(1) NOT NULL DEFAULT '0' COMMENT '含第三方检测',
@@ -4666,7 +4697,8 @@ CREATE TABLE `biz_qc_work_order` (
UNIQUE KEY `uk_qc_wo_reception` (`reception_id`,`del_flag`),
KEY `idx_qc_wo_tenant_status` (`tenant_no`,`work_order_status`,`del_flag`),
KEY `idx_qc_wo_sample_trigger` (`tenant_no`,`sample_code`,`trigger_source`,`del_flag`),
KEY `idx_qc_wo_prod_wo` (`production_work_order_id`,`del_flag`)
KEY `idx_qc_wo_prod_wo` (`production_work_order_id`,`del_flag`),
KEY `idx_qc_wo_prod_step_output` (`production_step_output_id`,`del_flag`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='质检工单';
-- ----------------------------
@@ -0,0 +1,926 @@
# 生产任务 · 工艺步骤级派发 Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** 将生产任务派发粒度从「整条任务 + 单一负责人」改为「工艺步骤 + 多人负责人 + 计划开始时间」;「我的生产任务」按步骤负责人过滤;执行弹窗内仅可操作派给自己的步骤。
**Architecture:** 新增 `biz_production_task_step_assignee`(对齐 `biz_qc_task_assignee`);步骤表增加 `planned_start_time`、`completed_by`;`PUT /production-tasks/{id}/steps/dispatch` 批量 sync 负责人;mine 鉴权从 `assert_task_assignee` 改为「任务级任一步 assignee OR 步骤级 assignee」+ 步骤写操作 `assert_step_assignee`;前端新增 `DispatchStepDialog.vue`,移除任务级负责人表单,隐藏任务转发/改派入口。
**Tech Stack:** MySQL 5.7 · FastAPI · SQLAlchemy · Pydantic v2 · Vue 3 · Element Plus · pnpm
**Design Spec:** `docs/superpowers/specs/2026-06-25-production-step-dispatch-design.md`
---
## File Map
| 文件 | 职责 |
|------|------|
| `docs/sql/migrations/2026-06-25-production-step-dispatch.sql` | 步骤字段 + assignee 表 |
| `docs/sql/migrations/2026-06-25-production-step-dispatch-backfill.sql` | 可选:旧任务 task assignee → 全步骤 assignee |
| `docs/sql/zkxw.sql` | 同步 DDL |
| `backend/app/models/models.py` | `BizProductionTaskStep` 新列 + `BizProductionTaskStepAssignee` |
| `backend/app/models/__init__.py` | export 新模型 |
| `backend/app/crud/production_task_step_assignee.py` | **新建** sync / enrich / validate |
| `backend/app/crud/production_task.py` | mine 过滤、dispatch、assert、completed_by、create 去 assignee 必填 |
| `backend/app/schemas/production_task.py` | `ProductionTaskStepDispatchBody`;Create 去必填 assignee |
| `backend/app/api/production.py` | `PUT steps/dispatch`;`_assert_*` 改造 |
| `web-admin/src/api/production-task.ts` | `fetchDispatchProductionTaskSteps`;create 去 assigneeUserId |
| `web-admin/src/views/production/production-work-order/DispatchStepDialog.vue` | **新建** 步骤派发表格弹窗 |
| `web-admin/src/views/production/production-work-order/DispatchTaskDialog.vue` | 移除任务负责人;B 入口打开步骤派发 |
| `web-admin/src/views/production/production-work-order/WorkOrderTaskSubList.vue` | 步骤派发按钮;隐藏转发/改派;展示步骤负责人 |
| `web-admin/src/views/production/production-work-order/TaskExecutionDialog.vue` | mine 步骤过滤 + 只读样式 |
| `web-admin/src/views/production/production-work-order/StepDetailPanel.vue` | `canEditStep` 控制按钮 |
| `web-admin/src/views/production/production-work-order/useTaskStepEditor.ts` | `canEditStep` / 完成写 completed_by 透传 |
---
## Task 1: 数据库迁移
**Files:**
- Create: `docs/sql/migrations/2026-06-25-production-step-dispatch.sql`
- Create: `docs/sql/migrations/2026-06-25-production-step-dispatch-backfill.sql`
- Modify: `docs/sql/zkxw.sql`(`biz_production_task_step` 与新建表片段)
- [ ] **Step 1: 编写主 migration**
```sql
-- docs/sql/migrations/2026-06-25-production-step-dispatch.sql
ALTER TABLE `biz_production_task_step`
ADD COLUMN `planned_start_time` datetime DEFAULT NULL COMMENT '计划开始时间' AFTER `step_status`;
ALTER TABLE `biz_production_task_step`
ADD COLUMN `completed_by` varchar(64) DEFAULT NULL COMMENT '完成步骤的用户ID' AFTER `completed_time`;
CREATE TABLE IF NOT EXISTS `biz_production_task_step_assignee` (
`id` varchar(64) NOT NULL COMMENT '主键',
`step_id` varchar(64) NOT NULL COMMENT '生产任务步骤ID',
`user_id` varchar(64) NOT NULL COMMENT '负责人用户ID',
`tenant_no` varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
`order_num` int DEFAULT 0 COMMENT '展示顺序',
`remark` varchar(512) DEFAULT NULL COMMENT '备注',
`create_by` varchar(64) DEFAULT NULL COMMENT '创建人id',
`create_dept_id` varchar(64) NOT NULL DEFAULT '' COMMENT '创建人部门ID',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_by` varchar(64) DEFAULT NULL COMMENT '更新人id',
`update_time` datetime NOT NULL COMMENT '更新时间',
`del_flag` tinyint NOT NULL DEFAULT 0 COMMENT '删除标记',
PRIMARY KEY (`id`),
KEY `idx_step_assignee_step` (`step_id`),
KEY `idx_step_assignee_user` (`user_id`, `tenant_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='生产任务步骤负责人';
```
- [ ] **Step 2: 编写可选 backfill(旧数据兼容)**
```sql
-- docs/sql/migrations/2026-06-25-production-step-dispatch-backfill.sql
-- 将仍有 task.current_assignee_user_id 且无步骤负责人的任务,回填到全部步骤
INSERT INTO biz_production_task_step_assignee (
id, step_id, user_id, tenant_no, order_num,
create_by, create_dept_id, create_time, update_by, update_time, del_flag
)
SELECT
REPLACE(UUID(), '-', ''),
s.id,
t.current_assignee_user_id,
s.tenant_no,
0,
t.create_by,
IFNULL(t.create_dept_id, ''),
NOW(),
t.update_by,
NOW(),
0
FROM biz_production_task t
JOIN biz_production_task_step s ON s.task_id = t.id AND s.del_flag = 0
WHERE t.del_flag = 0
AND t.current_assignee_user_id IS NOT NULL
AND TRIM(t.current_assignee_user_id) <> ''
AND NOT EXISTS (
SELECT 1 FROM biz_production_task_step_assignee a
WHERE a.step_id = s.id AND a.del_flag = 0
);
```
- [ ] **Step 3: 在开发/测试库执行主 migration**
Run:
```bash
mysql -u ... -p ... zkxw < docs/sql/migrations/2026-06-25-production-step-dispatch.sql
```
Expected: 两列新增成功;`biz_production_task_step_assignee` 表存在。
- [ ] **Step 4: 同步 `docs/sql/zkxw.sql` 对应 DDL**
---
## Task 2: Backend 模型
**Files:**
- Modify: `backend/app/models/models.py`
- Modify: `backend/app/models/__init__.py`
- [ ] **Step 1: 扩展 `BizProductionTaskStep`**
在 `step_status` 后、`started_time` 前增加:
```python
planned_start_time = Column(DateTime, nullable=True, comment="计划开始时间")
```
在 `completed_time` 后增加:
```python
completed_by = Column(String(64), nullable=True, comment="完成步骤的用户ID")
```
- [ ] **Step 2: 新增 `BizProductionTaskStepAssignee`**
放在 `BizProductionTaskStep` 附近,字段对齐 migration SQL(参照 `BizQcTaskAssignee`)。
- [ ] **Step 3: 注册 export**
`backend/app/models/__init__.py`:
```python
from app.models.models import (
# ...
BizProductionTaskStepAssignee,
)
__all__ = [
# ...
"BizProductionTaskStepAssignee",
]
```
---
## Task 3: Backend Schema
**Files:**
- Modify: `backend/app/schemas/production_task.py`
- [ ] **Step 1: 创建任务 body 去掉 assignee 必填**
```python
class ProductionTaskCreate(BaseModel):
model_config = ConfigDict(populate_by_name=True)
work_order_id: str
assignee_user_id: Optional[str] = Field(None, alias="assigneeUserId") # deprecated,可选
task_type: Optional[str] = 'cell_storage'
task_name: Optional[str] = None
route_id: Optional[str] = None
description: Optional[str] = None
remark: Optional[str] = None
```
- [ ] **Step 2: 新增步骤派发 body**
```python
class ProductionTaskStepDispatchItem(BaseModel):
model_config = ConfigDict(populate_by_name=True)
step_id: str = Field(..., alias="stepId")
assignee_user_ids: List[str] = Field(..., alias="assigneeUserIds", min_length=1)
planned_start_time: Optional[datetime] = Field(None, alias="plannedStartTime")
class ProductionTaskStepDispatchBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
steps: List[ProductionTaskStepDispatchItem] = Field(..., min_length=1)
```
---
## Task 4: 步骤负责人 CRUD 模块
**Files:**
- Create: `backend/app/crud/production_task_step_assignee.py`
- [ ] **Step 1: 创建模块(复制 QC 模式并改表名)**
```python
"""生产任务步骤负责人 CRUD"""
from __future__ import annotations
from datetime import datetime
from typing import Dict, List, Optional, Set
from sqlalchemy.orm import Session
from app.core.db_collation import eq_unicode
from app.core.utils import generate_uuid
from app.models.models import BizProductionTaskStepAssignee, SysUser
# validate_assignee_user_ids — 与 qc_task_assignee.validate_assignee_user_ids 相同逻辑
def sync_assignees_for_step(
db: Session,
step_id: str,
user_ids: List[str],
*,
tenant_no: str,
operator_id: Optional[str] = None,
create_dept_id: str = "",
) -> None:
"""全量替换步骤负责人(软删旧 + 插入新)。"""
# 实现同 qc_task_assignee.sync_assignees_for_task,表换 BizProductionTaskStepAssignee,FK 换 step_id
def enrich_step_assignees(
db: Session, steps: List[Dict], *, tenant_no: str
) -> None:
"""批量填充 assigneeUserIds / assigneeNames / assignees。"""
step_ids = [s["id"] for s in steps if s.get("id")]
if not step_ids:
return
rows = (
db.query(BizProductionTaskStepAssignee, SysUser)
.outerjoin(SysUser, eq_unicode(SysUser.id, BizProductionTaskStepAssignee.user_id))
.filter(
BizProductionTaskStepAssignee.step_id.in_(step_ids),
BizProductionTaskStepAssignee.tenant_no == tenant_no,
BizProductionTaskStepAssignee.del_flag == 0,
)
.order_by(BizProductionTaskStepAssignee.order_num.asc())
.all()
)
by_step: Dict[str, List] = {}
for assignee, user in rows:
by_step.setdefault(assignee.step_id, []).append((assignee, user))
for step in steps:
pairs = by_step.get(step["id"], [])
step["assigneeUserIds"] = [a.user_id for a, _ in pairs]
step["assigneeNames"] = [
f"{(u.nick_name or u.user_name or '')}({u.user_no or ''})".strip()
for _, u in pairs if u
]
step["assignees"] = [
{
"userId": a.user_id,
"nickName": (u.nick_name or u.user_name or "") if u else "",
"userNo": (u.user_no or "") if u else "",
}
for a, u in pairs
]
def user_is_step_assignee(
db: Session, step_id: str, user_id: str, tenant_no: str
) -> bool:
uid = (user_id or "").strip()
if not uid:
return False
return (
db.query(BizProductionTaskStepAssignee.id)
.filter(
BizProductionTaskStepAssignee.step_id == step_id,
BizProductionTaskStepAssignee.user_id == uid,
BizProductionTaskStepAssignee.tenant_no == tenant_no,
BizProductionTaskStepAssignee.del_flag == 0,
)
.first()
is not None
)
def user_is_any_step_assignee_of_task(
db: Session, task_id: str, user_id: str, tenant_no: str
) -> bool:
from app.models.models import BizProductionTaskStep
uid = (user_id or "").strip()
if not uid:
return False
return (
db.query(BizProductionTaskStepAssignee.id)
.join(
BizProductionTaskStep,
BizProductionTaskStep.id == BizProductionTaskStepAssignee.step_id,
)
.filter(
BizProductionTaskStep.task_id == task_id,
BizProductionTaskStep.del_flag == 0,
BizProductionTaskStepAssignee.user_id == uid,
BizProductionTaskStepAssignee.tenant_no == tenant_no,
BizProductionTaskStepAssignee.del_flag == 0,
)
.first()
is not None
)
```
- [ ] **Step 2: 本地 import smoke test**
Run:
```bash
cd backend && source venv/bin/activate
python -c "from app.crud import production_task_step_assignee; print('ok')"
```
Expected: `ok`
---
## Task 5: production_task.py — 步骤 dict、派发、mine 过滤
**Files:**
- Modify: `backend/app/crud/production_task.py`
- [ ] **Step 1: 扩展 `_step_to_dict`**
```python
def _step_to_dict(s: BizProductionTaskStep) -> Dict[str, Any]:
return {
# ... existing fields ...
"stepStatus": s.step_status or "dzx",
"plannedStartTime": _fmt_dt(getattr(s, "planned_start_time", None)),
"startedTime": _fmt_dt(s.started_time),
"completedTime": _fmt_dt(s.completed_time),
"completedBy": getattr(s, "completed_by", None) or "",
"completedByName": "",
"assigneeUserIds": [],
"assigneeNames": [],
"assignees": [],
"remark": s.remark or "",
}
```
- [ ] **Step 2: `create_production_task` 去掉 assignee 必填**
删除或注释:
```python
assignee_raw = (data.get("assignee_user_id") or data.get("assigneeUserId") or "").strip()
assignee_user_id = _validate_assignee_user_id(db, assignee_raw, tenant_no)
```
改为:
```python
assignee_raw = (data.get("assignee_user_id") or data.get("assigneeUserId") or "").strip()
assignee_user_id = assignee_raw.strip() or None
if assignee_raw.strip():
assignee_user_id = _validate_assignee_user_id(db, assignee_raw, tenant_no)
```
创建任务时:
```python
current_assignee_user_id=assignee_user_id, # 可为 NULL
```
- [ ] **Step 3: 新增 `dispatch_task_steps`**
```python
def dispatch_task_steps(
db: Session,
task_id: str,
*,
tenant_no: str,
steps_payload: List[Dict[str, Any]],
operator_id: Optional[str] = None,
create_dept_id: str = "",
) -> Dict[str, Any]:
from app.crud import production_task_step_assignee as step_assignee_svc
task = get_production_task_row(db, task_id, tenant_no)
if not task:
raise ValueError("任务不存在")
if not steps_payload:
raise ValueError("请至少指定一个步骤的负责人")
step_rows = {
s.id: s
for s in db.query(BizProductionTaskStep).filter(
BizProductionTaskStep.task_id == task_id,
BizProductionTaskStep.tenant_no == tenant_no,
BizProductionTaskStep.del_flag == 0,
).all()
}
for item in steps_payload:
sid = (item.get("step_id") or item.get("stepId") or "").strip()
if sid not in step_rows:
raise ValueError(f"步骤不存在或不属于该任务: {sid}")
user_ids = item.get("assignee_user_ids") or item.get("assigneeUserIds") or []
step_assignee_svc.sync_assignees_for_step(
db, sid, user_ids,
tenant_no=tenant_no,
operator_id=operator_id,
create_dept_id=create_dept_id,
)
step = step_rows[sid]
pst = item.get("planned_start_time") or item.get("plannedStartTime")
if pst is None and "plannedStartTime" in item and item.get("plannedStartTime") is None:
step.planned_start_time = None
elif pst:
from dateutil.parser import parse as _parse_dt
step.planned_start_time = _parse_dt(str(pst)) if not isinstance(pst, datetime) else pst
step.update_by = operator_id
step.update_time = datetime.now()
db.add(step)
db.flush()
detail = get_production_task_detail(db, task_id, tenant_no)
if not detail:
raise ValueError("任务不存在")
return detail
```
- [ ] **Step 4: 改造 `list_production_tasks` mine 过滤**
新增参数 `step_assignee_user_id: Optional[str] = None`。
在 `current_assignee_user_id` 过滤块 **之后** 增加:
```python
sa_uid = (step_assignee_user_id or "").strip()
if sa_uid:
step_task_ids = (
db.query(BizProductionTaskStep.task_id)
.join(
BizProductionTaskStepAssignee,
BizProductionTaskStepAssignee.step_id == BizProductionTaskStep.id,
)
.filter(
BizProductionTaskStepAssignee.user_id == sa_uid,
BizProductionTaskStepAssignee.tenant_no == tenant_no,
BizProductionTaskStepAssignee.del_flag == 0,
BizProductionTaskStep.del_flag == 0,
BizProductionTask.del_flag == 0,
)
.distinct()
.subquery()
)
q = q.filter(
or_(
BizProductionTask.id.in_(step_task_ids),
BizProductionTask.current_assignee_user_id == sa_uid, # 旧数据 fallback
)
)
```
- [ ] **Step 5: 改造 `list_mine_production_tasks`**
`scope=current` 时调用:
```python
return list_production_tasks(
# ...
step_assignee_user_id=uid,
current_assignee_user_id=None, # 不再仅用 task 级
# ...
)
```
保留 `current_assignee_user_id=uid` 作为 OR 条件已在 Step 4 合并;或直接只传 `step_assignee_user_id=uid` 并在 SQL 内 OR task assignee fallback。
- [ ] **Step 6: 新增 assert 函数**
```python
def assert_task_step_assignee_or_legacy(
db: Session, task_id: str, user_id: str, tenant_no: str
) -> BizProductionTask:
from app.crud import production_task_step_assignee as step_assignee_svc
task = get_production_task_row(db, task_id, tenant_no)
if not task:
raise ValueError("任务不存在")
if step_assignee_svc.user_is_any_step_assignee_of_task(db, task_id, user_id, tenant_no):
return task
if (task.current_assignee_user_id or "") == (user_id or ""):
return task
raise PermissionError("非任务步骤负责人,无权操作")
def assert_step_assignee_for_write(
db: Session,
step_id: str,
user_id: str,
tenant_no: str,
*,
manage: bool = False,
) -> BizProductionTaskStep:
if manage:
step = db.query(BizProductionTaskStep).filter(
BizProductionTaskStep.id == step_id,
BizProductionTaskStep.tenant_no == tenant_no,
BizProductionTaskStep.del_flag == 0,
).first()
if not step:
raise ValueError("步骤不存在")
return step
from app.crud import production_task_step_assignee as step_assignee_svc
step = db.query(BizProductionTaskStep).filter(
BizProductionTaskStep.id == step_id,
BizProductionTaskStep.tenant_no == tenant_no,
BizProductionTaskStep.del_flag == 0,
).first()
if not step:
raise ValueError("步骤不存在")
if not step_assignee_svc.user_is_step_assignee(db, step_id, user_id, tenant_no):
raise PermissionError("非当前步骤负责人,无权操作")
return step
```
- [ ] **Step 7: `update_task_step` 写 `completed_by`**
当 `data.get("step_status") == "ywc"` 且 `user_id` 存在:
```python
step.completed_by = user_id
```
- [ ] **Step 8: `get_production_task_detail` enrich 步骤 assignee**
加载 steps 后调用:
```python
from app.crud.production_task_step_assignee import enrich_step_assignees
enrich_step_assignees(db, steps, tenant_no=tenant_no)
# 可选:_enrich_completed_by_names
```
---
## Task 6: API 路由与鉴权
**Files:**
- Modify: `backend/app/api/production.py`
- [ ] **Step 1: 改造 `_assert_production_task_write_access`**
```python
def _assert_production_task_write_access(
db: Session,
user: dict,
task_id: str,
tenant_no: str,
operate_scope: Optional[str],
) -> None:
scope = (operate_scope or "manage").strip().lower()
user_id = _get_current_user_id(user)
role = user.get("role")
codes = get_user_menu_codes(db, user_id) if role != SUPER_ADMIN_ROLE else set()
if scope == "mine":
if role != SUPER_ADMIN_ROLE and "production:my-task:list" not in codes:
raise PermissionError("无菜单访问权限")
production_task_svc.assert_task_step_assignee_or_legacy(
db, task_id, user_id, tenant_no
)
elif role != SUPER_ADMIN_ROLE and "production:work-order:list" not in codes:
raise PermissionError("无菜单访问权限")
```
- [ ] **Step 2: 新增步骤写鉴权 helper**
```python
def _assert_production_task_step_write_access(
db: Session,
user: dict,
step_id: str,
tenant_no: str,
operate_scope: Optional[str],
) -> None:
scope = (operate_scope or "manage").strip().lower()
user_id = _get_current_user_id(user)
role = user.get("role")
codes = get_user_menu_codes(db, user_id) if role != SUPER_ADMIN_ROLE else set()
manage = scope != "mine"
if not manage:
if role != SUPER_ADMIN_ROLE and "production:my-task:list" not in codes:
raise PermissionError("无菜单访问权限")
elif role != SUPER_ADMIN_ROLE and "production:work-order:list" not in codes:
raise PermissionError("无菜单访问权限")
production_task_svc.assert_step_assignee_for_write(
db, step_id, user_id, tenant_no, manage=manage
)
```
- [ ] **Step 3: 注册 `PUT /production-tasks/{task_id}/steps/dispatch`**
```python
@router.put("/production-tasks/{task_id}/steps/dispatch")
async def dispatch_production_task_steps_api(
task_id: str,
body: ProductionTaskStepDispatchBody,
user: dict = Depends(require_menu_code("production:work-order:list")),
db: Session = Depends(get_db),
):
try:
tenant_no = _get_tenant_no(db, user)
payload = [
{
"step_id": it.step_id,
"assignee_user_ids": it.assignee_user_ids,
"planned_start_time": it.planned_start_time,
}
for it in body.steps
]
detail = production_task_svc.dispatch_task_steps(
db,
task_id,
tenant_no=tenant_no,
steps_payload=payload,
operator_id=user.get("user_id"),
create_dept_id=user.get("dept_id", ""),
)
db.commit()
return success_response(detail, message="步骤派发成功")
except ValueError as e:
db.rollback()
return error_response(400, str(e))
```
- [ ] **Step 4: 步骤写接口增加 step 级鉴权**
在以下 handler **内** `_assert_production_task_write_access` 之后追加 `_assert_production_task_step_write_access`:
- `update_production_task_step`
- `replace_task_step_reagents`
- `replace_task_step_consumables`
- `replace_task_step_configured_reagents`
- `replace_task_step_data_collections`
- `replace_task_step_outputs`
- `delete_production_task_step`
- `copy_production_task_step`
示例(`update_production_task_step`):
```python
_assert_production_task_write_access(db, user, task_id, tenant_no, operateScope)
_assert_production_task_step_write_access(db, user, step_id, tenant_no, operateScope)
```
任务级 inputs/outputs/attachments/status 仍只用 task 级 assert(D10:任一步 assignee 即可)。
- [ ] **Step 5: Swagger 手动验证**
Run backend,在 `/docs` 测试:
1. `PUT .../steps/dispatch` 返回 steps 含 `assigneeUserIds`
2. `GET .../production-tasks/mine?scope=current` 仅 assignee 可见
---
## Task 7: Frontend API
**Files:**
- Modify: `web-admin/src/api/production-task.ts`
- [ ] **Step 1: 新增 dispatch API**
```typescript
export function fetchDispatchProductionTaskSteps(
taskId: string,
data: {
steps: Array<{
stepId: string
assigneeUserIds: string[]
plannedStartTime?: string | null
}>
}
) {
return request.put<any>({
url: `/web/admin/production-tasks/${taskId}/steps/dispatch`,
data
})
}
```
- [ ] **Step 2: 确认 create 不再传 assigneeUserId**
`DispatchTaskDialog.vue` 将在 Task 9 移除该字段。
---
## Task 8: DispatchStepDialog.vue(新建)
**Files:**
- Create: `web-admin/src/views/production/production-work-order/DispatchStepDialog.vue`
- [ ] **Step 1: 实现弹窗骨架**
要点:
- Props: `visible`, `taskId`, `taskName?`
- 打开时 `fetchProductionTaskDetail(taskId)` 加载 `steps`
- 表格列:序号、`processName`、负责人多选(remote `fetchUserList`)、计划开始时间
- 本地 state:`rows: { stepId, processName, assigneeUserIds, plannedStartTime, userOptions }[]`
- 提交:过滤 `assigneeUserIds.length >= 1` 的行,调用 `fetchDispatchProductionTaskSteps`
- 校验:至少 1 行有负责人
- UI:`dialog-form-layout`、`label-position="top"`、footer Close/Check 图标
- [ ] **Step 2: 回显已有 assignee**
detail.steps 中若已有 `assigneeUserIds` / `plannedStartTime`,填入表单。
---
## Task 9: DispatchTaskDialog.vue 改造
**Files:**
- Modify: `web-admin/src/views/production/production-work-order/DispatchTaskDialog.vue`
- [ ] **Step 1: 移除任务级负责人**
删除表单项 `assigneeUserId`、`rules.assigneeUserId`、`form.assigneeUserId` 及 create payload 中的 `assigneeUserId`。
- [ ] **Step 2: B 入口 — 创建后打开步骤派发**
在 `handleCreateTask` 成功、`enterEditPhase` 之后:
```typescript
emit('open-step-dispatch', { taskId, taskName: form.taskName })
```
或由父组件监听 `@success` 并根据是否选了 `routeId` 打开 `DispatchStepDialog`。
推荐:Dialog 内 `emit('needStepDispatch', taskId)`,父组件 `WorkOrderTaskSubList` / `index.vue` 统一挂载 `DispatchStepDialog`。
- [ ] **Step 3: 若选了 route 且步骤已克隆**
创建成功 + `expectSteps` 为 true 时,关闭编辑阶段或保留编辑的同时弹出步骤派发(产品:B 入口)。
---
## Task 10: WorkOrderTaskSubList.vue 改造
**Files:**
- Modify: `web-admin/src/views/production/production-work-order/WorkOrderTaskSubList.vue`
- [ ] **Step 1: 挂载 DispatchStepDialog**
```vue
<DispatchStepDialog
v-model:visible="stepDispatchVisible"
:task-id="stepDispatchTaskId"
:task-name="stepDispatchTaskName"
@success="handleTaskMutationSuccess"
/>
```
- [ ] **Step 2: 管理视角增加「步骤派发」按钮**
在 `!isMineMode` 且任务非 `yzf` 时显示;文案:无 assignee 时「步骤派发」,否则「调整派发」。
判断:任一步 `assigneeUserIds?.length` 或后端返回 `hasStepDispatch`。
- [ ] **Step 3: 隐藏 deprecated 转发/改派**
删除或 `v-if="false"`:
- 下拉「转发任务」「改派负责人」
- `ForwardTaskDialog` 引用可保留文件但不挂载
- [ ] **Step 4: 任务卡片 meta 展示步骤负责人摘要**
在任务名下方增加 muted 文本,例如:`步骤负责人:张三、李四(细胞培养 09:00)` — 取前 2 步或折叠展示。
---
## Task 11: 执行弹窗 — 步骤权限与只读
**Files:**
- Modify: `web-admin/src/views/production/production-work-order/useTaskStepEditor.ts`
- Modify: `web-admin/src/views/production/production-work-order/TaskExecutionDialog.vue`
- Modify: `web-admin/src/views/production/production-work-order/StepDetailPanel.vue`
- [ ] **Step 1: useTaskStepEditor 增加 canEditStep**
```typescript
import { useUserStore } from '@/store/modules/user'
const userStore = useUserStore()
function canEditStep(step: Record<string, any> | null | undefined): boolean {
if (!step) return false
if (operateScope.value !== 'mine') return true
const uid = userStore.info?.id || userStore.userId || ''
const ids: string[] = step.assigneeUserIds || []
return ids.includes(uid)
}
function visibleStepsForMine(steps: Record<string, any>[]) {
if (operateScope.value !== 'mine') return steps
return steps.filter((s) => (s.assigneeUserIds || []).length > 0)
}
```
导出 `canEditStep`、`visibleStepsForMine`(或 computed `displayStepList`)。
- [ ] **Step 2: TaskExecutionDialog 步骤列表**
- mine:`v-for="element in editor.displayStepList"`(仅已派步骤)
- 对 `!canEditStep(element)` 的步骤加 class `is-readonly`(降低 opacity,禁用 drag)
- 任务级「转发任务」按钮移除
- [ ] **Step 3: StepDetailPanel 按钮**
```vue
<el-button
v-if="editor.mode.value === 'execution' && editor.canEditStep(editor.selectedStep.value)"
...
/>
```
保存 / 开始 / 完成均加 `canEditStep` 条件;只读时仅展示内容。
- [ ] **Step 4: 步骤写操作前端 guard(可选双保险)**
`handleStartStep` / `handleCompleteStep` 开头:
```typescript
if (!canEditStep(step)) {
ElMessage.warning('非当前步骤负责人,无法操作')
return
}
```
---
## Task 12: 字段一致性与图谱
**Files:**
- Run: `backend/scripts/check_field_consistency.py`(若涉及 CRUD 字段变更)
- Run: `./scripts/update-graph.sh backend frontend`
- [ ] **Step 1: 字段一致性检查**
Run:
```bash
cd backend && source venv/bin/activate
python scripts/check_field_consistency.py
```
Expected: 无 production_task step 相关新增不一致;若有 `_row_to_dict` 变更则修复 schema/前端。
- [ ] **Step 2: 更新知识图谱**
Run:
```bash
./scripts/update-graph.sh backend
./scripts/update-graph.sh frontend
```
---
## Task 13: 手工测试清单
- [ ] **B 入口**:生产工单 → 派发任务 → 选工艺路线 → 创建 → 步骤派发 → 用户 A/B 在「我的生产任务」见工单,执行时仅各自步骤可操作,其他只读。
- [ ] **A 入口**:无路线创建 → 手工加 3 步 → 步骤派发 → 同上。
- [ ] **一步多人**:A、B 同为步骤 1 负责人;A 完成步骤 1 后 B 见只读已完成。
- [ ] **同人多步**:步骤 1、2 均派给 A;A 两步均可操作。
- [ ] **计划开始时间**:卡片/派发弹窗展示;未到时间仍可执行。
- [ ] **未派步骤**:mine 执行弹窗不显示该步;manage 可见可操作。
- [ ] **改派**:manage 调整派发后,旧 assignee mine 列表消失(若无其他步骤),新 assignee 出现。
- [ ] **旧数据 backfill**(若执行 backfill SQL):原 task assignee 仍能在 mine 看到任务。
- [ ] **回归**:任务输入/产出/完成整单、派发质检工单链路不受影响。
---
## Spec Coverage Self-Review
| Spec 要求 | 对应 Task |
|-----------|-----------|
| D1 工单+任务列表 | Task 5 mine 过滤不变外层结构 |
| D2 其他步骤只读 | Task 11 |
| D3 一步多人任一完成 | Task 5 Step 7 completed_by |
| D4 计划开始时间不阻断 | Task 8/11 无前端时间校验 |
| D5 A+B 双入口 | Task 8/9/10 |
| D6 未派步骤仅 manage | Task 11 visibleStepsForMine |
| D7 方案 1 数据模型 | Task 1–4 |
| D8 任务 assignee 非必填 | Task 3/5 |
| D9 转发 deprecated | Task 10 |
| D10 任务 I/O 任一步 assignee | Task 6 task 级 assert |
| D11 mine 不可改派 | Task 6 dispatch 仅 work-order 权限 |
无 TBD 占位;类型命名 `assigneeUserIds` / `plannedStartTime` 前后端一致。
---
## 建议实施顺序
```
Task 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10 → 11 → 12 → 13
└─ backend 可联调 ─┘ └─ frontend ─────────────┘
```
Backend Task 1–6 完成后即可用 Swagger 验证 mine 过滤与 dispatch;Frontend Task 7–11 依赖后端 API。
@@ -0,0 +1,86 @@
# 编辑生产任务 · 步骤详情内派发字段 — 设计
> 日期: 2026-06-25
> 状态: **已评审,可实施**
> 依赖: `2026-06-25-production-step-dispatch-design.md`
---
## 1. 背景
【编辑生产任务】(`DispatchTaskDialog` 阶段二)使用三栏编辑器 + `StepDetailPanel`。步骤负责人与计划开始时间仅能通过独立弹窗 `DispatchStepDialog` 配置,步骤详情无展示与编辑入口,导致:
- 已派发数据在 API 中存在,右侧详情不可见;
- 工艺库新增步骤无法设置负责人与时间;
- 改派需切换弹窗,体验割裂。
## 2. 决策
| 项 | 决策 |
|----|------|
| 方案 | **A**:在 `StepDetailPanel` 增加负责人 + 计划开始时间 |
| 关闭校验 | **宽松**:关闭编辑弹窗时不强制每步均有负责人 |
| 保存策略 | **A1**:并入步骤「保存」按钮(`handleManualSave`) |
| 批量改派 | 保留 `DispatchStepDialog` 作批量入口 |
## 3. UI
### 3.1 展示条件
- `canEditStepDispatch()` 且 `!readonly`:可编辑控件(编辑工艺 / 任务执行,manage 与 mine 均可)
- 只读「任务详情」:展示文本 Tag / 时间,不可改
### 3.2 任务执行弹窗
- manage 与 **mine** 均在步骤详情可配置负责人与时间(保存时调 `steps/dispatch`,带 `operateScope`)
- mine 对未派发的新步骤:任务内任一步负责人可配置并保存
### 3.3 控件(对齐 `DispatchStepDialog`)
| 字段 | 控件 |
|------|------|
| 负责人 | `el-select` multiple + remote 用户搜索,`nickName(userNo)` |
| 计划开始时间 | `el-date-picker` datetime,`value-format="YYYY-MM-DDTHH:mm:00"`,可清空 |
置于步骤详情 `form-grid-4` 内(与工序名称等同区),label `label-position="top"`。
### 3.4 提示
- 无负责人时:字段下 muted 提示「未派发;保存工艺后可在本处或「步骤派发」中指定负责人」
## 4. 数据与保存
### 4.1 加载
- 任务详情 steps 已含 `assigneeUserIds`、`assignees`、`plannedStartTime`
- `normalizeStepSubTables` 补全 `assigneeUserIds`(来自 `assignees`),并记录快照 `_snapshotAssigneeUserIds`、`_snapshotPlannedStartTime` 用于脏检测
### 4.2 保存
- `handleManualSave` 在 `saveStepBasic` 等之后调用 `saveStepDispatch()`
- 仅当 `stepDispatchChanged(step)` 时调用 `PUT steps/dispatch`(单步 payload)
- 允许 `assigneeUserIds` 为空(清空负责人);`plannedStartTime` 传 `null` 表示清空
- 成功后更新快照,避免重复提交
### 4.3 关闭弹窗
- **不校验**全步骤是否已派发;未派步骤仍仅 manage 可见(沿用步骤派发设计 §1.2)
## 5. 文件
| 文件 | 变更 |
|------|------|
| `StepDetailPanel.vue` | 负责人、计划开始时间表单项 |
| `useTaskStepEditor.ts` | 用户搜索、`saveStepDispatch`、快照脏检测、并入 `handleManualSave` |
| `DispatchTaskDialog.vue` | 打开编辑时预加载用户列表(可选) |
## 6. 测试要点
1. 编辑工艺:已派发步骤在详情可见负责人与时间。
2. 修改负责人/时间后点「保存」,mine 列表与步骤派发弹窗数据一致。
3. 工艺库新增步骤:选中后可在详情设置并保存。
4. 清空负责人或计划时间后保存,DB 与再次打开一致。
5. 仅改工序名称未改派发字段时,保存不触发 dispatch API。
6. 关闭编辑弹窗:部分步骤未派发仍可关闭。
7. 工单页 · 任务执行(manage):工艺库新增步骤可在详情设负责人/时间并保存。
8. 我的生产任务 · 执行(mine):可编辑负责人/时间并保存(需为任务步骤负责人;未派发新步可由任务内负责人配置)。
@@ -0,0 +1,324 @@
# 生产任务 · 工艺步骤级派发 — 需求分析与设计
> 日期: 2026-06-25
> 状态: **已评审,可实施**
> 范围: web-admin + backend(生产工单派发、任务执行、我的生产任务)
---
## 1. 背景与目标
### 1.1 现状
| 项 | 现状 |
|----|------|
| 派发粒度 | `DispatchTaskDialog.vue` 创建 **整条生产任务** 时指定 **单一任务负责人**(`biz_production_task.current_assignee_user_id`) |
| 步骤模型 | `biz_production_task_step` 有工序与执行状态(`dzx/jxz/ywc`),**无负责人、无计划开始时间** |
| 我的生产任务 | 按 `current_assignee_user_id = 当前用户` 过滤任务 |
| 任务执行 | `TaskExecutionDialog.vue`:当前负责人对 **全部步骤** 可操作 |
| 类似实现 | 质检任务 **`biz_qc_task_assignee`**:每检测项多人负责,**任一可完成** |
### 1.2 客户需求(原文摘要)
1. **派发按工艺步骤**,而非整条生产任务整体派发。
2. **列表仍按工单 + 生产任务展示**;展开/进入执行后,**仅派给自己的步骤可操作**,其他步骤 **只读可见**。
3. 一个工艺步骤可 **同时派给多人**;**任一负责人** 可开始/完成该步骤。
4. 每个步骤派发时可设置 **计划开始时间**(展示/排序,**不限制**提前执行)。
5. 同一生产任务内,**多个步骤可派给同一人**。
6. 支持 **创建时一并派发(B)** 与 **工艺配置后单独派发(A)** 两种入口。
7. 已派给 A 的步骤,**可改派** 给其他人(更新负责人列表)。
8. **未指定负责人的步骤**:仅管理员在 **生产工单页** 可见可操作;**不出现在** 任何人的「我的生产任务」。
---
## 2. 产品决策
| # | 问题 | 决策 | 状态 |
|---|------|------|------|
| D1 | 「我的生产任务」列表粒度? | **工单 + 任务卡片**(非步骤级平铺列表) | ✅ |
| D2 | 未派给自己的步骤如何展示? | **只读可见**(可见完整工艺链路与状态,不可操作) | ✅ |
| D3 | 一步多人时的完成语义? | **任一负责人可独立完成**(与质检任务一致;`completed_by` 记实际操作人) | ✅ |
| D4 | 计划开始时间含义? | **仅展示/排序**,不阻断执行 | ✅ |
| D5 | 派发入口? | **A + B 均支持**,共用同一套步骤派发能力 | ✅ |
| D6 | 未派步骤可见性? | **仅管理员**(工单页 `operateScope=manage`);mine 不可见 | ✅ |
| D7 | 数据模型方案? | **方案 1**:`biz_production_task_step_assignee` + 步骤 `planned_start_time` | ✅ |
| D8 | 任务级负责人字段? | 创建时 **不再必填**;「我的生产任务」改按 **步骤负责人** 过滤 | ✅ |
| D9 | 任务级「转发」? | **保留代码但标记 deprecated**;协作改由 **步骤改派** 完成 | ✅ |
| D10 | 原材料/产出/纸质文档? | **任一步骤负责人** 在 mine 视角均可编辑(与步骤协作一致) | ✅ |
| D11 | mine 端能否自行改派? | **否**;改派仅 **工单管理页**(`operateScope=manage`) | ✅ |
---
## 3. 业务流程(目标态)
```
┌─────────────────────────────────────────────────────────────────────────┐
│ 生产工单 · 派发生产任务 │
│ 阶段一:任务名称、工艺路线(可选)、描述 — 【移除任务级负责人】 │
│ 阶段二:编辑工艺步骤(现有三栏编辑器) │
└─────────────────────────────────────────────────────────────────────────┘
│ 若选了工艺路线(B) │ 未选路线 / 后补步骤(A)
▼ ▼
┌────────────────────────────┐ ┌────────────────────────────┐
│ 创建后立即打开「步骤派发」 │ │ 任务卡片 · 「步骤派发」 │
│ 每步:多人 + 计划开始时间 │ │ 同上 │
└────────────────────────────┘ └────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 我的生产任务 · 工单 + 任务卡片 │
│ 过滤:当前用户是 ≥1 个步骤的负责人 │
│ 展开 → 进入执行:自己的步骤可操作;其他步骤只读;未派步骤 mine 不可见 │
└─────────────────────────────────────────────────────────────────────────┘
│
管理员工单页 · 步骤改派
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ sync 步骤负责人列表 + 更新 planned_start_time │
│ dzx/jxz:改派后新负责人可操作;ywc:仅影响可见性,不 reopen 步骤 │
└─────────────────────────────────────────────────────────────────────────┘
```
---
## 4. 数据模型
### 4.1 新增 / 变更
**步骤表扩展** `biz_production_task_step`:
```sql
ALTER TABLE biz_production_task_step
ADD COLUMN planned_start_time datetime DEFAULT NULL COMMENT '计划开始时间' AFTER step_status;
ALTER TABLE biz_production_task_step
ADD COLUMN completed_by varchar(64) DEFAULT NULL COMMENT '完成步骤的用户ID' AFTER completed_time;
```
**步骤负责人关联表** `biz_production_task_step_assignee`(对齐 `biz_qc_task_assignee`):
```sql
CREATE TABLE biz_production_task_step_assignee (
id varchar(64) NOT NULL COMMENT '主键',
step_id varchar(64) NOT NULL COMMENT '生产任务步骤ID',
user_id varchar(64) NOT NULL COMMENT '负责人用户ID',
tenant_no varchar(64) NOT NULL DEFAULT 'zkxw' COMMENT '租户编号',
order_num int DEFAULT 0 COMMENT '展示顺序',
remark varchar(512) DEFAULT NULL COMMENT '备注',
create_by varchar(64) DEFAULT NULL COMMENT '创建人id',
create_dept_id varchar(64) NOT NULL DEFAULT '' COMMENT '创建人部门ID',
create_time datetime NOT NULL COMMENT '创建时间',
update_by varchar(64) DEFAULT NULL COMMENT '更新人id',
update_time datetime NOT NULL COMMENT '更新时间',
del_flag tinyint NOT NULL DEFAULT 0 COMMENT '删除标记',
PRIMARY KEY (id),
KEY idx_step_assignee_step (step_id),
KEY idx_step_assignee_user (user_id, tenant_no)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='生产任务步骤负责人';
```
### 4.2 任务级字段(兼容)
| 字段 | 处理 |
|------|------|
| `biz_production_task.current_assignee_user_id` | **保留列**;新创建任务可为 NULL;API 创建 body **移除 assigneeUserId 必填** |
| `biz_production_task_handover` | **保留**;UI 不再主推「任务转发」,文档标注 deprecated |
### 4.3 历史数据迁移(可选脚本)
- 若旧任务 `current_assignee_user_id` 非空且无步骤负责人:可将该用户写入 **全部现有步骤** 的 assignee(一次性迁移),保证旧任务仍在「我的生产任务」可见。
- 无 assignee 且无步骤负责人的旧任务:行为与「未派步骤」一致,仅 manage 可见。
---
## 5. API 设计
### 5.1 步骤派发(批量)
```
PUT /api/web/admin/production-tasks/{taskId}/steps/dispatch
```
**Body**(camelCase 与现有约定一致):
```json
{
"steps": [
{
"stepId": "uuid",
"assigneeUserIds": ["u1", "u2"],
"plannedStartTime": "2026-06-25T09:00:00"
}
]
}
```
**规则:**
- 至少 **1 个 step** 在请求中且 `assigneeUserIds.length >= 1`(允许部分步骤暂不派)。
- 未出现在请求中的步骤:**不修改** 其负责人与时间。
- 出现的步骤:**全量 sync** 负责人(软删旧 + 插入新,复用 `qc_task_assignee.sync_assignees` 模式)。
- `plannedStartTime` 可选;传 null 表示清空。
- 权限:`production:work-order:list`(manage);mine 端 **403**。
**响应:** 任务详情(含 steps、assignees、plannedStartTime、assigneeNames)。
### 5.2 创建生产任务
```
POST /api/web/admin/production-tasks
```
- **移除** `assigneeUserId` 必填校验。
- 可选扩展:同 body 内嵌 `stepDispatch` 数组(B 入口一次提交);或创建成功后前端再调 §5.1。
### 5.3 我的生产任务列表
```
GET /api/web/admin/production-tasks/mine
```
**过滤逻辑变更:**
- **current**:存在 `biz_production_task_step_assignee.user_id = 当前用户` 且 `del_flag=0` 的 **至少一个步骤** 的任务。
- **history**(若保留):曾出现在步骤 assignee 但当前已不在任一步 assignee 列表的任务(可选首版简化:与 current 合并或暂不实现 history 变更)。
> 首版:**替换** 原 `current_assignee_user_id = 我` 为主过滤条件;history 沿用 handover 逻辑仅作兼容,不作为步骤协作主路径。
### 5.4 步骤写操作鉴权
| 操作 | mine | manage |
|------|------|--------|
| 开始/完成/保存 **已派给自己** 的步骤 | ✅ | ✅ |
| 操作 **未派给自己** 的步骤 | ❌ 只读 | ✅ |
| 操作 **未派任何人** 的步骤 | ❌ 不可见 | ✅ |
| 编辑任务输入/产出/附件 | ✅ 若本人是任一步 assignee | ✅ |
| 步骤派发/改派 | ❌ | ✅ |
实现:在 `production_task` CRUD 增加 `assert_step_assignee(step_id, user_id)`;manage 路径跳过。
### 5.5 任务详情 / 列表 enrichment
- `_task_to_dict` / 步骤 `_step_to_dict` 增加:
- `assigneeUserIds: string[]`
- `assigneeNames: string[]`(或 `assignees: {userId, nickName, userNo}[]`)
- `plannedStartTime`
- `completedBy` / `completedByName`
- 列表接口批量 `_enrich_step_assignees`(对齐 QC `_enrich_assignee_names`)。
---
## 6. 前端设计
### 6.1 新增组件
| 组件 | 职责 |
|------|------|
| `DispatchStepDialog.vue` | 步骤派发表格:工序名、负责人多选、计划开始时间;提交 §5.1 |
### 6.2 改造组件
| 组件 | 变更 |
|------|------|
| `DispatchTaskDialog.vue` | **移除** 任务级「负责人」表单项与校验;选工艺路线且创建成功后 **可选打开** `DispatchStepDialog`(B) |
| `WorkOrderTaskSubList.vue` | 管理视角:任务卡片 meta 展示各步负责人 Tag + 计划开始时间;按钮「步骤派发 / 调整派发」 |
| `TaskExecutionDialog.vue` | mine:`canEditStep(step)` = 当前用户在 step.assigneeUserIds;否则只读;未派步骤不渲染或 manage 才显示 |
| `StepDetailPanel.vue` | 禁用开始/完成/保存按钮当 `!canEditStep` |
| `useTaskStepEditor.ts` | 传入 `operateScope`;步骤操作前校验 assignee |
| `production-task.ts` | 新增 `fetchDispatchProductionTaskSteps`;创建 body 去掉 assigneeUserId |
| `production-mine-task-groups.ts` | mine 列表依赖后端新过滤(前端无需按 task assignee 过滤) |
### 6.3 步骤派发表格 UI
| 列 | 控件 |
|----|------|
| 序号 / 工序名称 | 只读 |
| 负责人 | `el-select multiple filterable remote`,展示 `nickName(userNo)`,≥1 |
| 计划开始时间 | `el-date-picker type="datetime"`,可选 |
- 弹窗:`dialog-form-layout`,`label-position="top"`。
- 底栏:取消 / 确定(Close / Check 图标)。
### 6.4 执行弹窗 · 步骤列表视觉
- **可操作步骤**:现有高亮样式(`is-active`)。
- **只读步骤**:降低 opacity 或 `readonly` class;隐藏开始/完成/保存;保留状态 Tag。
- **未派步骤(mine)**:不展示(manage 正常展示并可操作)。
### 6.5 Deprecated UI
- 任务级「转发」「改派」按钮:管理页 **隐藏或替换** 为「步骤派发」;API 保留不删。
---
## 7. 改派规则
| 步骤状态 | 改负责人 | 改计划开始时间 | 步骤是否 reopen |
|----------|----------|----------------|-----------------|
| `dzx` | ✅ | ✅ | — |
| `jxz` | ✅ | ✅ | 否,新负责人接手进行中步骤 |
| `ywc` | ✅(仅影响 mine 可见性) | ✅ | **否** |
---
## 8. 任务 / 工单状态联动
- **任务状态**(`dpz/jxz/ywc`)逻辑 **不变**:仍由步骤聚合 + 现有 `sync_production_work_order_status_from_tasks` 驱动。
- **未派步骤** 不参与 mine 过滤;manage 仍可执行未派步骤(管理员兜底)。
---
## 9. 权限与菜单
| 能力 | menuCode |
|------|----------|
| 生产工单(manage、步骤派发) | `production:work-order:list` |
| 我的生产任务 | `production:my-task:list` |
无需新增菜单;步骤派发挂在工单页任务操作区。
---
## 10. 测试要点
1. B 入口:选路线 → 创建 → 步骤派发 → 各 assignee 在 mine 见任务,仅自己步骤可操作。
2. A 入口:无路线创建 → 手工加步骤 → 步骤派发 → 同上。
3. 一步多人:A、B 均可见任务;A 完成后 B 见只读已完成。
4. 同人多步:mine 展开见多个可操作步骤。
5. 计划开始时间:列表/卡片展示;未到时间仍可执行。
6. 未派步骤:mine 不可见;manage 可见可操作。
7. 改派:`dzx/jxz/ywc` 按 §7;mine 不可改派。
8. 旧任务兼容(若跑迁移脚本):原 task assignee 仍可见。
---
## 11. 文件清单(实施参考)
| 层 | 文件 |
|----|------|
| SQL | `docs/sql/migrations/2026-06-25-production-step-dispatch.sql`,同步 `docs/sql/zkxw.sql` |
| Backend Model | `backend/app/models/models.py` — `BizProductionTaskStepAssignee` + 步骤新字段 |
| Backend CRUD | `backend/app/crud/production_task_step_assignee.py`(新建,对齐 qc_task_assignee) |
| Backend CRUD | `backend/app/crud/production_task.py` — mine 过滤、step assert、complete 写 completed_by |
| Backend Schema | `backend/app/schemas/production_task.py` — DispatchStepsBody |
| Backend API | `backend/app/api/production.py` — PUT steps/dispatch;调整 create/mine |
| Frontend API | `web-admin/src/api/production-task.ts` |
| Frontend | `DispatchStepDialog.vue`(新建) |
| Frontend | `DispatchTaskDialog.vue`, `WorkOrderTaskSubList.vue`, `TaskExecutionDialog.vue`, `StepDetailPanel.vue`, `useTaskStepEditor.ts` |
---
## 12. 与 OpenSpec / 既有 spec 关系
- supersede 部分:`2026-06-13-production-task-assignee-my-tasks-design.md` 中 **任务级单一负责人 + 任务转发** 产品路径;本 spec 以 **步骤级多人 + 步骤改派** 为准。
- 对齐 `api-conventions`:租户隔离、软删除、`operateScope=mine|manage`。
- 对齐 `ui-conventions`:Fresh Mint 弹窗、按钮图标、Tag 展示负责人。
---
## 13. 版本记录
| 日期 | 说明 |
|------|------|
| 2026-06-25 | 初稿:步骤级派发方案 1,产品决策 D1–D11 已确认 |