package logic // 2026-11-05 叫料包拍板支持层(叫料与送料彻底拆开): // ① CallPlanDetail 叫料需求明细(工单×排产日×物料,实时计算不落库)——池底层 工位×物料 // 聚合记账不动(两层并存),本明细层供「当日剩余没叫/跨日量」提示与 plan_breakdown 拆分。 // ② EnsureStationDocksEmpty / StationDockPallets 两接驳台都为空才能叫料(传感器为准)。 // ③ DispatchPalletReturnManual 托盘回库(传感器为准、台账软校验,不一致由操作人确认留痕)。 // ④ ClearDockLedger 人工清台(托盘被人工卸走后台账卡死兜底;仅清台账不碰账)。 // ⑤ DispatchDeliveryAgv 配送单派车(WMS 配送单驱动,BizNo=配送单号)。 // ⑥ StationMaterialDetail 工位物料明细(工艺物料全集 左连接 工位账四数,量为0也显示)。 import ( "context" "errors" "fmt" "math" "sort" "strconv" "time" "bj_power_mes/ent" "bj_power_mes/ent/callpool" "bj_power_mes/ent/dailyplan" "bj_power_mes/ent/dock" "bj_power_mes/ent/flowmaterial" "bj_power_mes/ent/materialrequest" "bj_power_mes/ent/workorder" "bj_power_mes/schema" ) // ErrDockPLCOffline PLC 离线无法核实接驳台为空(前端提示后可强行提交——离线降级拍板口径) var ErrDockPLCOffline = errors.New("PLC 离线,无法确认接驳台是否为空") // CallPlanDetailRow 叫料需求明细行(工单×排产日×物料维度) type CallPlanDetailRow struct { PlanDate string `json:"planDate"` OrderNo string `json:"orderNo"` FlowID int `json:"flowId"` FlowName string `json:"flowName"` MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` NeedQty int `json:"needQty"` CalledQty int `json:"calledQty"` RemainQty int `json:"remainQty"` } // CallPlanDetail 明细全集 + 两类提示(当日剩余没叫 / 跨日量明细)——实时计算不落库不拦提交 type CallPlanDetail struct { Today string `json:"today"` Rows []CallPlanDetailRow `json:"rows"` TodayRemain []CallPlanDetailRow `json:"todayRemain"` CrossDayRemain []CallPlanDetailRow `json:"crossDayRemain"` } // CallPlanDetail 叫料需求明细:复刻 recomputePoolStations 的派生算法,按 工单×排产日×物料 展开; // 已叫量从 material_request.plan_breakdown 汇总(存量单 breakdown 为空时按 call_date/工单号归并)。 func (s *Service) CallPlanDetail(ctx context.Context, stationNo int) (*CallPlanDetail, error) { today := time.Now().Format("2006-01-02") type key struct { date string order string flow int mat string } need := map[key]*CallPlanDetailRow{} plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.Status("CONFIRMED")).All(ctx) if err != nil { return nil, err } flowNameCache := map[int]string{} for _, p := range plans { wo, werr := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.WorkOrderNo(p.OrderNo)).First(ctx) if werr != nil || wo == nil { continue } items, rerr := RouteStationsFromWO(ctx, s.ctx.EntClient, wo) if rerr != nil || len(items) == 0 { continue } fmByFlow := map[int][]*ent.FlowMaterial{} for _, it := range items { if _, done := fmByFlow[it.FlowId]; done { continue } fms, ferr := s.ctx.EntClient.FlowMaterial.Query(). Where(flowmaterial.FlowId(it.FlowId)).All(ctx) if ferr != nil { continue } fmByFlow[it.FlowId] = fms } stationsByFlow := map[int][]int{} for _, it := range items { stationsByFlow[it.FlowId] = append(stationsByFlow[it.FlowId], it.StationNo) } stationQty := map[int]int{} for k, v := range p.StationPlanQty { if n, e := strconv.Atoi(k); e == nil { stationQty[n] = v } } for flowId, stations := range stationsByFlow { fms := fmByFlow[flowId] if len(fms) == 0 { continue } qtys := splitQtyToStations(stations, p.PlanQty, stationQty) for i, stNo := range stations { if stNo != stationNo { continue } q := qtys[i] if q <= 0 { continue } if _, ok := flowNameCache[flowId]; !ok { flowNameCache[flowId] = s.flowNameById(ctx, flowId) } for _, fm := range fms { if fm.MaterialCode == "" { continue } needQty := int(math.Ceil(float64(q) * fm.UnitQty)) if needQty <= 0 { continue } k := key{p.PlanDate, p.OrderNo, flowId, fm.MaterialCode} r := need[k] if r == nil { r = &CallPlanDetailRow{PlanDate: p.PlanDate, OrderNo: p.OrderNo, FlowID: flowId, FlowName: flowNameCache[flowId], MaterialCode: fm.MaterialCode, MaterialName: fm.MaterialName, Unit: fm.Unit} need[k] = r } r.NeedQty += needQty } } } } // 已叫量:活跃叫料单(待备料/已发货/已完成——已取消/已驳回/退库不计) called := map[key]int{} mrs, _ := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.StationNo(stationNo), materialrequest.StatusIn("PENDING", "SHIPPED", "DONE")).All(ctx) for _, mr := range mrs { if len(mr.PlanBreakdown) > 0 { for _, b := range mr.PlanBreakdown { called[key{b.PlanDate, b.OrderNo, b.FlowID, mr.MaterialCode}] += int(b.Qty) } } else { // 存量单兼容:无明细按 叫料日×工单号 归并(空=未拆分) called[key{mr.CallDate, mr.WorkOrderNo, 0, mr.MaterialCode}] += int(mr.ReqQty) } } out := CallPlanDetail{Today: today, Rows: []CallPlanDetailRow{}, TodayRemain: []CallPlanDetailRow{}, CrossDayRemain: []CallPlanDetailRow{}} for k, r := range need { r.CalledQty = called[k] if r.CalledQty > r.NeedQty { r.CalledQty = r.NeedQty } r.RemainQty = r.NeedQty - r.CalledQty out.Rows = append(out.Rows, *r) if r.RemainQty > 0 { if k.date == today { out.TodayRemain = append(out.TodayRemain, *r) } else { out.CrossDayRemain = append(out.CrossDayRemain, *r) } } } sort.Slice(out.Rows, func(i, j int) bool { a, b := out.Rows[i], out.Rows[j] if a.PlanDate != b.PlanDate { return a.PlanDate < b.PlanDate } if a.OrderNo != b.OrderNo { return a.OrderNo < b.OrderNo } return a.MaterialCode < b.MaterialCode }) sort.Slice(out.TodayRemain, func(i, j int) bool { return out.TodayRemain[i].MaterialCode < out.TodayRemain[j].MaterialCode }) sort.Slice(out.CrossDayRemain, func(i, j int) bool { a, b := out.CrossDayRemain[i], out.CrossDayRemain[j] if a.PlanDate != b.PlanDate { return a.PlanDate < b.PlanDate } return a.MaterialCode < b.MaterialCode }) return &out, nil } // splitPlanBreakdown 把本次叫料量按 工单×排产日 明细拆分(FIFO:最早排产日优先、同日按工单号序); // 只分配「需求−已叫」的余量;无可分配明细时退化为单行(planDate=叫料日,存量兼容)。 func (s *Service) splitPlanBreakdown(ctx context.Context, stationNo int, materialCode string, qty int, callDate string) []schema.CallPlanBreakdown { detail, err := s.CallPlanDetail(ctx, stationNo) if err != nil || detail == nil { return []schema.CallPlanBreakdown{{PlanDate: callDate, Qty: float64(qty)}} } out := []schema.CallPlanBreakdown{} for _, r := range detail.Rows { if qty <= 0 { break } if r.MaterialCode != materialCode { continue } room := r.NeedQty - r.CalledQty if room <= 0 { continue } take := room if take > qty { take = qty } out = append(out, schema.CallPlanBreakdown{OrderNo: r.OrderNo, PlanDate: r.PlanDate, FlowID: r.FlowID, FlowName: r.FlowName, Qty: float64(take)}) qty -= take } if qty > 0 { out = append(out, schema.CallPlanBreakdown{PlanDate: callDate, Qty: float64(qty)}) } return out } // DockPalletState 接驳台托盘状态(实时传感器为准;PLC 不可达时回退台账并标注 plcOk=false) type DockPalletState struct { DockCode string `json:"dockCode"` Name string `json:"name"` Side string `json:"side"` HasPallet bool `json:"hasPallet"` LedgerPallet bool `json:"ledgerPallet"` PlcOk bool `json:"plcOk"` } // StationDockPallets 按工位批量读左右接驳台实时传感器(叫料空台校验/下班校验共用)。 func (s *Service) StationDockPallets(ctx context.Context, stationNo int) ([]DockPalletState, error) { dks, err := s.ctx.EntClient.Dock.Query(). Where(dock.StationNo(stationNo)).Order(ent.Asc(dock.FieldDockCode)).All(ctx) if err != nil { return nil, err } out := []DockPalletState{} for _, d := range dks { if d.Status == "DISABLED" { continue } st := DockPalletState{DockCode: d.DockCode, Name: d.Name, Side: d.Side, LedgerPallet: d.HasPallet, HasPallet: d.HasPallet} if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() { if has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, d.DockCode); e == nil { st.PlcOk = true st.HasPallet = has } } out = append(out, st) } return out, nil } // EnsureStationDocksEmpty 两接驳台都为空才允许叫料(2026-11-05 拍板:提交时校验)。 // 传感器为准;PLC 离线返回 ErrDockPLCOffline(前端提示后可强行提交);台账仅软校验留痕。 func (s *Service) EnsureStationDocksEmpty(ctx context.Context, stationNo int) error { if s.ctx.PLC == nil || s.ctx.PLC.IsMock() { return nil // mock PLC 无真实传感器:跳过校验 } dks, err := s.ctx.EntClient.Dock.Query(). Where(dock.StationNo(stationNo)).All(ctx) if err != nil || len(dks) == 0 { return nil // 无接驳台配置不拦 } for _, d := range dks { if d.Status == "DISABLED" { continue } has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, d.DockCode) if e != nil { return ErrDockPLCOffline } if has { return fmt.Errorf("工位%d 接驳台 %s(%s)有托盘,请先退料或点「托盘回库」拉走后再叫料", stationNo, d.DockCode, d.Name) } if d.HasPallet { // 台账与传感器不一致:以传感器(空)为准放行,留痕 s.ctx.EventLog.Write(ctx, "dock.pallet_mismatch", "", "", "dock", d.DockCode, "叫料空台校验:台账有托盘但传感器为空,以传感器为准放行", nil) } } return nil } // DispatchPalletReturnManual 工位终端「托盘回库」(2026-11-05 拍板): // 物理拉回仓库 JBT21,不是退料——物料账仍挂工位、WMS 库存不变(PALLET 链不碰任何账), // 系统内一律按空托盘理解(盘上有无料都不管)。判定以传感器为准、台账软校验; // 不一致由操作人确认(confirmHasPallet=true)并留痕。 func (s *Service) DispatchPalletReturnManual(ctx context.Context, dockCode, operator string, confirmHasPallet bool) error { d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx) if err != nil || d == nil { return fmt.Errorf("接驳台 %s 不存在", dockCode) } if d.Status == "DISABLED" { return fmt.Errorf("接驳台 %s 已停用", dockCode) } hasPallet := d.HasPallet plcOk := false if s.ctx.PLC != nil && !s.ctx.PLC.IsMock() { if has, e := s.ctx.PLC.Get().QueryDockPallet(ctx, dockCode); e == nil { plcOk = true hasPallet = has } } if plcOk && !hasPallet { if d.HasPallet && !confirmHasPallet { return errors.New("传感器显示该接驳台无托盘(台账有托盘)。如托盘确实已不在台上,请库管在 WMS 托盘工作台「人工清台」更正;如确认有托盘,请勾选「确认台上有托盘」后重试") } if !d.HasPallet { return fmt.Errorf("接驳台 %s 无托盘,无需回库", dockCode) } // 操作人坚持有托盘:按台账派车并留痕 s.ctx.EventLog.Write(ctx, "dock.pallet_return_confirm", operator, "", "dock", dockCode, "托盘回库:传感器为空但操作人确认台上有托盘,按台账派车", nil) } else if !plcOk && !hasPallet { return fmt.Errorf("接驳台 %s 台账无托盘(PLC 离线无法核实),无需回库", dockCode) } if free, reason := s.Jbt21Free(ctx); !free { return fmt.Errorf("库房接驳台 %s 暂无空位:%s。请先卸走库房接驳台上的托盘后再派车", dockStoreCode, reason) } _, err = s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "GO_LOAD", BizType: "PALLET", BizNo: dockCode, Source: "", Target: dockCode, Operator: operator, }) if err == nil { s.ctx.EventLog.Write(ctx, "dock.pallet_return", operator, "", "dock", dockCode, "托盘回库已派车(物理拉回仓库,非退料;物料账与库存不变)", nil) } return err } // ClearDockLedger 人工清台(2026-11-05 兜底):托盘被人工卸走(未走 AGV)后台账卡 hasPallet=true, // 会卡住 Jbt21Free 空位判定与防撞校验——库管在 WMS 托盘工作台手动清台并留痕。 // 仅清台账,不碰任何库存/池账/工件账。 func (s *Service) ClearDockLedger(ctx context.Context, dockCode, operator, reason string) error { d, err := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockCode)).First(ctx) if err != nil || d == nil { return fmt.Errorf("接驳台 %s 不存在", dockCode) } if !d.HasPallet { return errors.New("该接驳台账账本无托盘,无需清台") } if uerr := s.ctx.EntClient.Dock.UpdateOneID(d.ID).SetHasPallet(false).SetPalletRef("").Exec(ctx); uerr != nil { return uerr } s.ctx.EventLog.Write(ctx, "dock.manual_clear", operator, "", "dock", dockCode, "人工清台:台账置无托盘(托盘已被人工卸走;物料账/库存不变) 原因:"+reason, nil) return nil } // DeliveryAgvItem 配送单物料行(WMS 派车时传入) type DeliveryAgvItem struct { RequestNo string `json:"requestNo"` MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` Qty float64 `json:"qty"` } // DispatchDeliveryAgv 配送单派车(2026-11-05 拍板:AGV 派车改配送单驱动): // WMS 校验配送单后转发(BizType=CALL、BizNo=配送单号、关联单号=配送单号)→ // 空车段(GO_LOAD)前往装货点 JBT21 → 到位待令 → 库管「确认装车并送货」 // (目标=配送单接驳台,随物料行下发)→ 卸货放行后经 /api/internal/delivery/delivered 回写已送达。 func (s *Service) DispatchDeliveryAgv(ctx context.Context, deliveryNo, targetDock string, items []DeliveryAgvItem, operator string) error { if deliveryNo == "" || targetDock == "" { return errors.New("配送单号与配送接驳台必填") } if len(items) == 0 { return errors.New("配送单无明细,不能派车") } if d, derr := s.ctx.EntClient.Dock.Query().Where(dock.DockCodeEQ(dockStoreCode)).First(ctx); derr == nil && d != nil && d.Status == "DISABLED" { return fmt.Errorf("库房接驳台 %s 已停用,拒绝派车(请恢复接驳台或人工配送)", dockStoreCode) } rows := make([]AgvSubmitRow, 0, len(items)) for _, it := range items { rows = append(rows, AgvSubmitRow{RequestNo: deliveryNo, MaterialCode: it.MaterialCode, MaterialName: it.MaterialName, Unit: it.Unit, Qty: it.Qty, TargetDock: targetDock}) } s.checkSensorVsLedger(ctx, dockStoreCode, true, deliveryNo) taskNo, err := s.dispatchAgvSegment(ctx, agvSegInput{ Kind: "GO_LOAD", BizType: "CALL", BizNo: deliveryNo, Source: "", Target: dockStoreCode, Materials: rows, Operator: operator, }) if err != nil { return err } s.ctx.EventLog.Write(ctx, "delivery.dispatch", "", operator, "delivery_order", deliveryNo, fmt.Sprintf("配送单 %s 派车成功(AGV 任务 %s,目标 %s)", deliveryNo, taskNo, targetDock), nil) return nil } // StationMaterialDetailRow 工位物料明细行(工艺物料全集 左连接 工位账四数) type StationMaterialDetailRow struct { MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Spec string `json:"spec"` Unit string `json:"unit"` SnMode int `json:"snMode"` FlowName string `json:"flowName"` ReqQty int `json:"reqQty"` AdjQty int `json:"adjQty"` SentQty int `json:"sentQty"` AvailQty int `json:"availQty"` } // StationMaterialDetail 工位物料明细(2026-11-05 拍板:比叫料列表更突出,量为0也显示、 // 不分左右托盘):工艺全集 = 活跃工单(下发/进行/暂停)组合中绑定本工位的工艺; // 池(工位×物料)为记账层,两层并存。 func (s *Service) StationMaterialDetail(ctx context.Context, stationNo int) ([]StationMaterialDetailRow, error) { flowIds := map[int]bool{} wos, _ := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.StatusIn("RELEASED", "IN_PROGRESS", "PAUSED")).All(ctx) for _, wo := range wos { items, err := RouteStationsFromWO(ctx, s.ctx.EntClient, wo) if err != nil { continue } for _, it := range items { if it.StationNo == stationNo { flowIds[it.FlowId] = true } } } poolRows, _ := s.ctx.EntClient.CallPool.Query().Where(callpool.StationNo(stationNo)).All(ctx) poolBy := map[string]*ent.CallPool{} for _, r := range poolRows { poolBy[r.MaterialCode] = r } out := []StationMaterialDetailRow{} seen := map[string]bool{} fidList := make([]int, 0, len(flowIds)) for fid := range flowIds { fidList = append(fidList, fid) } sort.Ints(fidList) for _, fid := range fidList { fms, _ := s.ctx.EntClient.FlowMaterial.Query().Where(flowmaterial.FlowId(fid)).All(ctx) for _, fm := range fms { if fm.MaterialCode == "" || seen[fm.MaterialCode] { continue } seen[fm.MaterialCode] = true row := StationMaterialDetailRow{MaterialCode: fm.MaterialCode, MaterialName: fm.MaterialName, Spec: fm.Spec, Unit: fm.Unit, SnMode: fm.SnMode, FlowName: s.flowNameById(ctx, fid)} if r := poolBy[fm.MaterialCode]; r != nil { row.ReqQty = r.ReqQty row.AdjQty = r.AdjQty row.SentQty = r.SentQty row.AvailQty = poolAvail(r.ReqQty, r.AdjQty, r.SentQty, r.ReservedQty) } out = append(out, row) } } // 有在途/占用但活跃工艺已不再覆盖的物料也补出(池有、工艺无:显示为「—」工艺) keys := make([]string, 0, len(poolBy)) for k := range poolBy { keys = append(keys, k) } sort.Strings(keys) for _, mc := range keys { if seen[mc] { continue } seen[mc] = true r := poolBy[mc] row := StationMaterialDetailRow{MaterialCode: mc, MaterialName: r.MaterialName, Unit: r.Unit, SnMode: r.SnMode, FlowName: "—"} row.ReqQty = r.ReqQty row.AdjQty = r.AdjQty row.SentQty = r.SentQty row.AvailQty = poolAvail(r.ReqQty, r.AdjQty, r.SentQty, r.ReservedQty) out = append(out, row) } return out, nil }