Files
bj_power/bj_power_mes/internal/logic/route.go
T

363 lines
14 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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)
}