363 lines
14 KiB
Go
363 lines
14 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"bj_power_mes/ent"
|
||
"bj_power_mes/ent/productprocessitem"
|
||
"bj_power_mes/ent/station"
|
||
"bj_power_mes/ent/workorder"
|
||
"bj_power_mes/internal/verr"
|
||
)
|
||
|
||
// ---------- 工单工艺组合(work_order.flow_combination)路线派生 ----------
|
||
|
||
// TodayStr 当天日期 yyyy-MM-dd(工位停单只认当天)
|
||
func TodayStr() string { return time.Now().Format("2006-01-02") }
|
||
|
||
// FlowItem 工单工艺组合条目:工艺 + 工位(工位号即顺序号,按工位号升序执行)
|
||
type FlowItem struct {
|
||
FlowId int `json:"flowId"`
|
||
StationNo int `json:"stationNo"`
|
||
}
|
||
|
||
// RouteStationsFromWO 解析工单 flow_combination → 组合条目(按工位号升序;空组合返回空切片)
|
||
func RouteStationsFromWO(ctx context.Context, client *ent.Client, wo *ent.WorkOrder) ([]FlowItem, error) {
|
||
if wo == nil {
|
||
return nil, nil
|
||
}
|
||
items := flowMapsToItems(wo.FlowCombination)
|
||
sort.SliceStable(items, func(i, j int) bool { return items[i].StationNo < items[j].StationNo })
|
||
return items, nil
|
||
}
|
||
|
||
// flowMapsToItems jsonb 原始值 → 组合条目(过滤 flowId 非正 / stationNo 为 0 的脏条目;
|
||
// stationNo 允许负数:负数=产线前段虚拟工位,2026-11-02)
|
||
func flowMapsToItems(raw []map[string]int) []FlowItem {
|
||
items := make([]FlowItem, 0, len(raw))
|
||
for _, m := range raw {
|
||
flowId, no := m["flowId"], m["stationNo"]
|
||
if flowId > 0 && no != 0 {
|
||
items = append(items, FlowItem{FlowId: flowId, StationNo: no})
|
||
}
|
||
}
|
||
return items
|
||
}
|
||
|
||
// flowItemsToMaps 组合条目 → jsonb 存储结构
|
||
func flowItemsToMaps(items []FlowItem) []map[string]int {
|
||
out := make([]map[string]int, 0, len(items))
|
||
for _, it := range items {
|
||
out = append(out, map[string]int{"flowId": it.FlowId, "stationNo": it.StationNo})
|
||
}
|
||
return out
|
||
}
|
||
|
||
// RouteStationsOfWO 组合条目 → 工位号列表(升序;未选工位即跳过)
|
||
func RouteStationsOfWO(items []FlowItem) []int {
|
||
out := make([]int, 0, len(items))
|
||
for _, it := range items {
|
||
out = append(out, it.StationNo)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// RouteStationsStrOfWO 组合条目 → 路线串 "2,5,6,8"
|
||
func RouteStationsStrOfWO(items []FlowItem) string {
|
||
parts := make([]string, 0, len(items))
|
||
for _, it := range items {
|
||
parts = append(parts, strconv.Itoa(it.StationNo))
|
||
}
|
||
return strings.Join(parts, ",")
|
||
}
|
||
|
||
// StationFlowMapOfWO 组合条目 → 工位号→工艺ID
|
||
func StationFlowMapOfWO(items []FlowItem) map[int]int {
|
||
m := make(map[int]int, len(items))
|
||
for _, it := range items {
|
||
m[it.StationNo] = it.FlowId
|
||
}
|
||
return m
|
||
}
|
||
|
||
// ---------- 并行候选工位:工序级路线(一道工序可配置多个候选工位) ----------
|
||
|
||
// FlowRouteStep 工序级路线步骤:一道工序(工艺) + 其全部候选工位。
|
||
// 并行模型(2026-11-02):工件在任一候选工位报工一次即完成该工序,候选工位间为「可任选」关系而非串行顺序。
|
||
type FlowRouteStep struct {
|
||
FlowId int // 工艺ID
|
||
Stations []int // 候选工位号(升序)
|
||
MinNo int // 候选最小工位号(用于工序顺序)
|
||
MaxNo int // 候选最大工位号(用于进度推进)
|
||
Seq int // 工序顺序(按 MinNo 升序,从1起)
|
||
}
|
||
|
||
// groupFlowRoute 扁平组合条目 → 工序级路线(同 flowId 归并为一道工序,多工位为其候选集)。
|
||
// 工序顺序按各工序候选最小工位号升序(产线单向不回头)。
|
||
func groupFlowRoute(items []FlowItem) []FlowRouteStep {
|
||
byFlow := map[int][]int{}
|
||
for _, it := range items {
|
||
byFlow[it.FlowId] = append(byFlow[it.FlowId], it.StationNo)
|
||
}
|
||
steps := make([]FlowRouteStep, 0, len(byFlow))
|
||
for fid, sts := range byFlow {
|
||
sort.Ints(sts)
|
||
steps = append(steps, FlowRouteStep{FlowId: fid, Stations: sts, MinNo: sts[0], MaxNo: sts[len(sts)-1]})
|
||
}
|
||
sort.SliceStable(steps, func(i, j int) bool { return steps[i].MinNo < steps[j].MinNo })
|
||
for i := range steps {
|
||
steps[i].Seq = i + 1
|
||
}
|
||
return steps
|
||
}
|
||
|
||
// FlowRouteOfWO 工单 flow_combination → 工序级路线(含候选工位)。
|
||
func FlowRouteOfWO(ctx context.Context, client *ent.Client, wo *ent.WorkOrder) ([]FlowRouteStep, error) {
|
||
if wo == nil {
|
||
return nil, nil
|
||
}
|
||
return groupFlowRoute(flowMapsToItems(wo.FlowCombination)), nil
|
||
}
|
||
|
||
// GroupFlowRoute 导出版:扁平组合条目 → 工序级路线(handler 包渲染流程卡用)。
|
||
func GroupFlowRoute(items []FlowItem) []FlowRouteStep {
|
||
return groupFlowRoute(items)
|
||
}
|
||
|
||
// DistinctFlowCount 路线中工序(工艺)去重计数:并行模型下完工/进度按「工序数」而非「工位数」判定。
|
||
func DistinctFlowCount(items []FlowItem) int {
|
||
m := map[int]bool{}
|
||
for _, it := range items {
|
||
m[it.FlowId] = true
|
||
}
|
||
return len(m)
|
||
}
|
||
|
||
// intsContains 整数切片包含判断(候选工位校验用)。
|
||
func intsContains(ns []int, v int) bool {
|
||
for _, n := range ns {
|
||
if n == v {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// FlowUsedByActiveOrders 工艺是否被「执行中/已暂停」工单的工艺组合引用(2026-11-02 条目12 守卫)。
|
||
// 背景:工单 flow_combination 是建单快照,但生产流程卡的定义层(工序清单/步骤门禁)每次
|
||
// 请求实时渲染 ProcessFlow/ProcessStep——改基础工艺会改掉在产工单的流程卡展示。
|
||
// 与产品工艺规则1同口径:执行中禁改,建议复制新工艺给新工单用。命中返回工单号列表。
|
||
func (s *Service) FlowUsedByActiveOrders(ctx context.Context, flowId int) ([]string, error) {
|
||
wos, err := s.ctx.EntClient.WorkOrder.Query().
|
||
Where(workorder.StatusIn("IN_PROGRESS", "PAUSED")).All(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var hit []string
|
||
for _, w := range wos {
|
||
for _, m := range w.FlowCombination {
|
||
if m["flowId"] == flowId {
|
||
hit = append(hit, w.WorkOrderNo)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return hit, nil
|
||
}
|
||
|
||
// guardFlowEditable 基础工艺内容(名称/步骤/绑定/物料清单/删除)变更守卫:
|
||
// 被执行中/已暂停工单引用 → 拒绝并给出「怎么办」。
|
||
func (s *Service) guardFlowEditable(ctx context.Context, flowId int) error {
|
||
hits, err := s.FlowUsedByActiveOrders(ctx, flowId)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if len(hits) > 0 {
|
||
return fmt.Errorf("该工艺被执行中/已暂停的工单引用(%s),不能修改或删除;如需调整请复制一份新工艺,新工单使用新工艺",
|
||
strings.Join(hits, "、"))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ValidateFlowCombination 保存工单时校验工艺组合(收集式实现,见 ValidateFlowCombinationCollect;
|
||
// 保留原签名供既有调用方使用,错误为收集式 ValidationError,handler 经 FailErr 输出结构化清单)。
|
||
func (s *Service) ValidateFlowCombination(ctx context.Context, raw []map[string]int) ([]FlowItem, error) {
|
||
items, ve := s.ValidateFlowCombinationCollect(ctx, raw)
|
||
return items, ve.OrNil()
|
||
}
|
||
|
||
// ValidateFlowCombinationCollect 收集式组合校验(报错一次收全,2026-10-20):
|
||
// 逐条检查每个组合项,重复/停用/不存在/绑定不匹配等问题全部列出、不串行 return;
|
||
// 每条错误带「怎么办」,能跳转解决的给 action(去工艺页/去工位管理)。
|
||
func (s *Service) ValidateFlowCombinationCollect(ctx context.Context, raw []map[string]int) ([]FlowItem, *verr.ValidationError) {
|
||
items := flowMapsToItems(raw)
|
||
ve := verr.New()
|
||
if len(items) == 0 {
|
||
ve.Add("flowCombination", "请先选择工艺组合", "至少选择一条「工艺+工位」:从产品工艺带出,或在工单编辑中手动勾选")
|
||
return nil, ve
|
||
}
|
||
sort.SliceStable(items, func(i, j int) bool { return items[i].StationNo < items[j].StationNo })
|
||
seen := map[int]bool{}
|
||
for _, it := range items {
|
||
if seen[it.StationNo] {
|
||
ve.Add("flowCombination", fmt.Sprintf("工位 %d 在工艺组合中重复", it.StationNo),
|
||
fmt.Sprintf("同一工位只能出现一次,删除工位 %d 的重复行", it.StationNo))
|
||
continue
|
||
}
|
||
seen[it.StationNo] = true
|
||
flow, err := s.ctx.EntClient.ProcessFlow.Get(ctx, it.FlowId)
|
||
if err != nil {
|
||
ve.Add("flowCombination", fmt.Sprintf("工艺不存在(ID=%d)", it.FlowId),
|
||
"删除该组合行后,从工艺下拉中重新选择")
|
||
continue
|
||
}
|
||
if flow.Status != "ACTIVE" {
|
||
ve.AddAction("flowCombination", fmt.Sprintf("工艺「%s」已停用", flow.Name),
|
||
"到「工艺」页启用该工艺,或在组合中移除该工艺行", "去工艺页", "/process-flow")
|
||
continue
|
||
}
|
||
exist, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(it.StationNo)).First(ctx)
|
||
if err != nil {
|
||
ve.Add("flowCombination", fmt.Sprintf("工位 %d 不存在", it.StationNo),
|
||
"在组合中移除该工位行,或到「工位管理」新增该工位")
|
||
continue
|
||
}
|
||
// 工位当前绑定工艺必须与工单一致且工位启用(与排产校验 ValidateWOCombinationForSchedule 同口径),
|
||
// 否则工单下发后工位被改绑/停用会导致路线漂移
|
||
if exist.Status != "ENABLED" {
|
||
ve.AddAction("flowCombination", fmt.Sprintf("工位%d 已停用", it.StationNo),
|
||
"到「工位管理」启用该工位,或在组合中移除该工位行", "去工位管理", "/station")
|
||
} else if exist.FlowId != it.FlowId {
|
||
ve.AddAction("flowCombination", fmt.Sprintf("工位%d 当前绑定工艺与工单不一致", it.StationNo),
|
||
fmt.Sprintf("到「工位管理」把工位%d 绑回「%s」,或在组合中改选该工位当前绑定的工艺", it.StationNo, flow.Name),
|
||
"去工位管理", "/station")
|
||
}
|
||
}
|
||
return items, ve
|
||
}
|
||
|
||
// ValidateWorkOrderComboStrict 工单工艺组合「工序工位」严格校验(2026-10-20 工单建单需求:自动推荐+用户可改+动态约束)。
|
||
// 仅在带产品工艺(productProcessId>0)时生效;无产品工艺则交由既有逻辑(组合可选)。
|
||
// 三条硬规则,收集式一次列全(与 ValidateFlowCombinationCollect 合并返回):
|
||
// ① 每道工序都选了工位(产品工艺的每道工艺在组合中须有对应记录);
|
||
// ② 工位号按工序顺序严格递增(产线单向不回头,不允许倒序流转);
|
||
// ③ 每个工位确实绑定对应工序 —— 由 ValidateFlowCombinationCollect 同口径兜底(含停用/改绑/不存在,消息带「怎么办」)。
|
||
func (s *Service) ValidateWorkOrderComboStrict(ctx context.Context, ppId int, combo []map[string]int) *verr.ValidationError {
|
||
ve := verr.New()
|
||
if ppId <= 0 {
|
||
return ve
|
||
}
|
||
if _, err := s.ctx.EntClient.ProductProcess.Get(ctx, ppId); err != nil {
|
||
return ve // 产品工艺不存在时交给来源工艺存在性校验,避免重复
|
||
}
|
||
items, err := s.ctx.EntClient.ProductProcessItem.Query().
|
||
Where(productprocessitem.ProductProcessId(ppId)).
|
||
Order(ent.Asc(productprocessitem.FieldSeq)).All(ctx)
|
||
if err != nil || len(items) == 0 {
|
||
return ve
|
||
}
|
||
flows, _ := s.ctx.EntClient.ProcessFlow.Query().All(ctx)
|
||
flowName := map[int]string{}
|
||
for _, f := range flows {
|
||
flowName[f.ID] = f.Name
|
||
}
|
||
// 组合按 flowId 归并(一道工序可配置多个有序工位:基于「产线单向不回头」,
|
||
// 本道工序的全部工位必须都在上一道工序的全部工位之后,即各工序的工位区间互不交叉、整体严格递增)。
|
||
byFlow := map[int][]int{}
|
||
for _, c := range combo {
|
||
fid, no := c["flowId"], c["stationNo"]
|
||
if fid > 0 && no != 0 {
|
||
byFlow[fid] = append(byFlow[fid], no)
|
||
}
|
||
}
|
||
for k := range byFlow {
|
||
sort.Ints(byFlow[k])
|
||
}
|
||
prevName, prevMax := "", 0
|
||
for _, it := range items {
|
||
name := flowName[it.FlowId]
|
||
if name == "" {
|
||
name = "工序" + strconv.Itoa(it.FlowId)
|
||
}
|
||
sts := byFlow[it.FlowId]
|
||
if len(sts) == 0 {
|
||
// 规则①:该道工序未选工位
|
||
ve.Add("flowCombination",
|
||
fmt.Sprintf("第%d道工序「%s」未选工位", it.Seq, name),
|
||
fmt.Sprintf("请为第%d道工序「%s」选择至少一个绑定了该工序的工位", it.Seq, name))
|
||
continue
|
||
}
|
||
// 同工序内重复工位(脏数据)拦截
|
||
seen := map[int]bool{}
|
||
dup := false
|
||
for _, n := range sts {
|
||
if seen[n] {
|
||
dup = true
|
||
break
|
||
}
|
||
seen[n] = true
|
||
}
|
||
if dup {
|
||
ve.Add("flowCombination",
|
||
fmt.Sprintf("第%d道工序「%s」的工位列表存在重复(工位%d)", it.Seq, name, sts[0]),
|
||
fmt.Sprintf("请在第%d道工序「%s」中去重工位", it.Seq, name))
|
||
continue
|
||
}
|
||
minS, maxS := sts[0], sts[len(sts)-1]
|
||
if prevMax > 0 && minS <= prevMax {
|
||
// 规则②:本道工序工位区间未整体在上一道之后(产线单向不能回头 / 工序工位不可交叉)
|
||
ve.Add("flowCombination",
|
||
fmt.Sprintf("第%d道工序「%s」的工位(%s)未整体排在上一道工序「%s」(工位%d)之后",
|
||
it.Seq, name, strings.Join(intsToStrs(sts), ","), prevName, prevMax),
|
||
fmt.Sprintf("产线单向不能回头:请把工序「%s」的工位都改到工位%d 之后,或调整工序顺序",
|
||
name, prevMax))
|
||
}
|
||
prevName, prevMax = name, maxS
|
||
}
|
||
return ve
|
||
}
|
||
|
||
// intsToStrs 整数切片转字符串切片(校验消息用)
|
||
func intsToStrs(ns []int) []string {
|
||
out := make([]string, 0, len(ns))
|
||
for _, n := range ns {
|
||
out = append(out, "工位"+strconv.Itoa(n))
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ValidateWOCombinationForSchedule 排产前校验(工单组合是唯一路线源头,排产只继承不可改):
|
||
// 组合为空不可排产;组合里每个工位当前绑定工艺必须与工单一致且工位启用。
|
||
func (s *Service) ValidateWOCombinationForSchedule(ctx context.Context, wo *ent.WorkOrder) error {
|
||
items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo)
|
||
if len(items) == 0 {
|
||
return errors.New("请先在工单中选择工艺组合,才能排产")
|
||
}
|
||
for _, it := range items {
|
||
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(it.StationNo)).First(ctx)
|
||
if err != nil {
|
||
return fmt.Errorf("工位 %d 不存在", it.StationNo)
|
||
}
|
||
if st.FlowId != it.FlowId || st.Status != "ENABLED" {
|
||
return fmt.Errorf("工位%d当前工艺与工单不匹配", it.StationNo)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// flowNameById 工艺名称(查不到回退「工艺{id}」)
|
||
func (s *Service) flowNameById(ctx context.Context, id int) string {
|
||
if id > 0 {
|
||
if f, err := s.ctx.EntClient.ProcessFlow.Get(ctx, id); err == nil && f.Name != "" {
|
||
return f.Name
|
||
}
|
||
}
|
||
return "工艺" + strconv.Itoa(id)
|
||
}
|