package logic import ( "context" "errors" "fmt" "math" "sort" "strconv" "strings" "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/station" "bj_power_mes/ent/workorder" ) // ============ B5 叫料池 + 叫料单(2026-10-13 定稿) ============ // // 池子来源:启用状态(CONFIRMED)的日排产 × 工单工艺组合(flow_combination) × 工艺物料清单(flow_material), // 按 工位+物料 聚合成 call_pool 行;需求量 = Σ 该工位排产量 × 单台用量 ×(1+损耗率),逐排产行向上取整后求和。 // 四数账(一个字段只有一个写者): // req_qty 需求 [写者:排产派生重算] // adj_qty 调整 [写者:人工改量 AdjustPoolQty,留痕 event_log] // sent_qty 已发 [写者:仓库完成备料 CompleteCall 累加实发;确认收回 ConfirmReturn 扣减回补] // reserved_qty 占用 [写者:发起叫料占用;完成/取消/驳回释放] // 可用 = req + adj − sent − reserved(<0 截断为 0 展示,不回收已占)。 // 叫料单七态:PENDING 待备料 → SHIPPED 已发货 → DONE 已完成(签收); // 分支终态 CANCELLED(待备料撤销)/REJECTED(仓库拒发);退库 RETURNING → RETURNED(仓库确认收回,仅签收前)。 // BorrowSource 同工序候选工位的某物料可借明细(供工位端手动分配借料来源) type BorrowSource struct { StationNo int `json:"stationNo"` Avail int `json:"avail"` } // CallPoolRow 叫料池行(含派生可用量,供叫料页) type CallPoolRow struct { StationNo int `json:"stationNo"` MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` SnMode int `json:"snMode"` ReqQty int `json:"reqQty"` AdjQty int `json:"adjQty"` SentQty int `json:"sentQty"` ReservedQty int `json:"reservedQty"` AvailQty int `json:"availQty"` BorrowAvail int `json:"borrowAvail"` // 同工序其他工位对该物料的可借剩余额度(仅供前端提示与限额) BorrowSources []BorrowSource `json:"borrowSources"` // 同工序其他工位该物料的可借明细(stationNo→可用),供手动分配借料 CrossDay bool `json:"crossDay"` PlanDates string `json:"planDates"` } // CallItem 叫料明细行:一个物料 + 一个量 + 一个目标接驳台 = 一张叫料单 = 一个托盘 = 一次配送 type CallItem struct { MaterialCode string `json:"materialCode"` Qty int `json:"qty"` Dock string `json:"dock"` Borrow map[string]int `json:"borrow"` // 超额时的借料分配:来源工位号(字符串)→借用量;空=不借(本工位自取) } // CallQuery 叫料单查询条件(零值=不过滤) type CallQuery struct { Status string MaterialCode string MaterialName string TargetDock string StationNo string Source string // CALL / REFILL RequestNo string } func poolAvail(req, adj, sent, reserved int) int { a := req + adj - sent - reserved if a < 0 { return 0 } return a } // distributeAmount 把 total 按 alloc 各来源的占比拆分到来源工位,保证各来源合计 == total、 // 且每来源不超过其预约量 alloc;余数按工位号升序逐 1 补齐(用于借料场景的实发/退库回补分摊)。 // alloc 为空或 total<=0 返回空表。 func distributeAmount(total int, alloc map[string]int) map[string]int { out := map[string]int{} if total <= 0 || len(alloc) == 0 { return out } sum := 0 keys := make([]string, 0, len(alloc)) for k, v := range alloc { keys = append(keys, k) sum += v } if sum <= 0 { return out } sort.Strings(keys) rem := total for _, k := range keys { f := total * alloc[k] / sum if f > rem { f = rem } out[k] = f rem -= f } for i := 0; i < len(keys) && rem > 0; i++ { out[keys[i]]++ rem-- } return out } // borrowLogEntry 收集一次叫料中"涉及借料"的明细,待事务提交后写操作日志(避免事务回滚产生孤儿日志) type borrowLogEntry struct { reqNo string materialCode string alloc map[string]int } // borrowDetail 生成借料追溯描述(不含操作人前缀): // "向工位[6]借用[3]个[物料A],向工位[9]借用[2]个[物料A],共借料[5]个(本工位自取[5]个)";无借料返回空串。 func borrowDetail(alloc map[string]int, self int, materialCode string) string { parts := []string{} total := 0 selfAmt := 0 keys := make([]string, 0, len(alloc)) for k := range alloc { keys = append(keys, k) } sort.Strings(keys) for _, k := range keys { v := alloc[k] total += v n, e := strconv.Atoi(k) if e != nil || n == self { selfAmt += v continue } parts = append(parts, fmt.Sprintf("向工位[%d]借用[%d]个[%s]", n, v, materialCode)) } if len(parts) == 0 { return "" } return fmt.Sprintf("%s,共借料[%d]个(本工位自取[%d]个)", strings.Join(parts, ","), total, selfAmt) } // splitQtyToStations 把日总量 dayQty 拆分到 stations 各工位: // 优先使用 stationQty 显式分配(其和>0 时直接采用);否则平均分配(余数补到前面工位)。 func splitQtyToStations(stations []int, dayQty int, stationQty map[int]int) []int { n := len(stations) out := make([]int, n) usePlan := true sum := 0 for _, st := range stations { v, ok := stationQty[st] if !ok { usePlan = false break } sum += v } if usePlan && sum > 0 { for i, st := range stations { out[i] = stationQty[st] } return out } if n == 0 { return out } base := dayQty / n for i := 0; i < n; i++ { out[i] = base } for i := 0; i < dayQty-base*n; i++ { out[i]++ } return out } // RecomputePoolAll 全量重算叫料池(seed/migrate 后一键对齐;返回变更行数)。 func (s *Service) RecomputePoolAll(ctx context.Context) (int, error) { sts, err := s.ctx.EntClient.Station.Query().All(ctx) if err != nil { return 0, err } nos := make([]int, 0, len(sts)) for _, st := range sts { nos = append(nos, st.StationNo) } return s.recomputePoolStations(ctx, nos) } // recomputePoolStations 重算指定工位的池子行:聚合全部启用排产的贡献后 upsert; // 不再有贡献的行:有在途(已发/占用非0)的 req 置 0(不回收已占),无在途的删除。 func (s *Service) recomputePoolStations(ctx context.Context, stationNos []int) (int, error) { if len(stationNos) == 0 { return 0, nil } want := map[int]bool{} for _, n := range stationNos { want[n] = true } type agg struct { qty int name string unit string snMode int dates map[string]bool cross bool } aggMap := map[string]*agg{} // key: stationNo|materialCode today := time.Now().Format("2006-01-02") plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.Status("CONFIRMED")).All(ctx) if err != nil { return 0, err } 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 !want[stNo] { continue } q := qtys[i] if q <= 0 { continue } for _, fm := range fms { if fm.MaterialCode == "" { continue } // R7(2026-11-03 拍板):备料量=工单需求×单台用量,不预放折损率;损耗走补料审批(shortage) need := int(math.Ceil(float64(q) * fm.UnitQty)) if need <= 0 { continue } key := strconv.Itoa(stNo) + "|" + fm.MaterialCode a := aggMap[key] if a == nil { a = &agg{dates: map[string]bool{}} aggMap[key] = a } a.qty += need a.name = fm.MaterialName a.unit = fm.Unit a.snMode = fm.SnMode a.dates[p.PlanDate] = true if p.PlanDate != today { a.cross = true } } } } } changed := 0 existing, err := s.ctx.EntClient.CallPool.Query(). Where(callpool.StationNoIn(stationNos...)).All(ctx) if err != nil { return 0, err } existMap := map[string]*ent.CallPool{} for _, r := range existing { existMap[strconv.Itoa(r.StationNo)+"|"+r.MaterialCode] = r } for key, a := range aggMap { parts := strings.SplitN(key, "|", 2) stNo, _ := strconv.Atoi(parts[0]) dates := make([]string, 0, len(a.dates)) for d := range a.dates { dates = append(dates, d) } sort.Strings(dates) planDates := strings.Join(dates, ",") if r, ok := existMap[key]; ok { if r.ReqQty != a.qty || r.MaterialName != a.name || r.Unit != a.unit || r.SnMode != a.snMode || r.CrossDay != a.cross || r.PlanDates != planDates { if _, uerr := s.ctx.EntClient.CallPool.UpdateOneID(r.ID). SetReqQty(a.qty).SetMaterialName(a.name).SetUnit(a.unit).SetSnMode(a.snMode). SetCrossDay(a.cross).SetPlanDates(planDates).Save(ctx); uerr != nil { return changed, uerr } changed++ } delete(existMap, key) continue } if _, cerr := s.ctx.EntClient.CallPool.Create(). SetStationNo(stNo).SetMaterialCode(parts[1]). SetMaterialName(a.name).SetUnit(a.unit).SetSnMode(a.snMode). SetReqQty(a.qty).SetCrossDay(a.cross).SetPlanDates(planDates).Save(ctx); cerr != nil { return changed, cerr } changed++ } // 无贡献的存量行:有在途 → req 置 0(不回收已占/已发);无在途 → 删除 for _, r := range existMap { if r.SentQty != 0 || r.ReservedQty != 0 { if r.ReqQty != 0 { if _, uerr := s.ctx.EntClient.CallPool.UpdateOneID(r.ID).SetReqQty(0).Save(ctx); uerr == nil { changed++ } } continue } if derr := s.ctx.EntClient.CallPool.DeleteOneID(r.ID).Exec(ctx); derr == nil { changed++ } } return changed, nil } // StationPool 查某工位的叫料池行(叫料页;可用量 + 同工序可借额度派生)。 func (s *Service) StationPool(ctx context.Context, stationNo int) ([]CallPoolRow, error) { rows, err := s.ctx.EntClient.CallPool.Query(). Where(callpool.StationNo(stationNo)). Order(ent.Asc(callpool.FieldMaterialCode)).All(ctx) if err != nil { return nil, err } // 同工序候选工位对该物料的可借剩余额度明细(仅同 FlowId 的启用工位之间可借;且须基础设置开启借料) borrowByMat := map[string]int{} borrowSrcByMat := map[string][]BorrowSource{} if allowBorrow := s.CfgInt(ctx, CfgAllowBorrow, 1) == 1; allowBorrow { if self, e := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx); e == nil && self.FlowId > 0 { if sibs, e2 := s.ctx.EntClient.Station.Query(). Where(station.FlowId(self.FlowId), station.StationNoNEQ(stationNo), station.StatusEQ("ENABLED")).All(ctx); e2 == nil && len(sibs) > 0 { sibNos := make([]int, 0, len(sibs)) for _, sb := range sibs { sibNos = append(sibNos, sb.StationNo) } if sibRows, e3 := s.ctx.EntClient.CallPool.Query().Where(callpool.StationNoIn(sibNos...)).All(ctx); e3 == nil { for _, sr := range sibRows { a := poolAvail(sr.ReqQty, sr.AdjQty, sr.SentQty, sr.ReservedQty) if a <= 0 { continue } borrowByMat[sr.MaterialCode] += a borrowSrcByMat[sr.MaterialCode] = append(borrowSrcByMat[sr.MaterialCode], BorrowSource{StationNo: sr.StationNo, Avail: a}) } } } } } for k := range borrowSrcByMat { sort.Slice(borrowSrcByMat[k], func(i, j int) bool { return borrowSrcByMat[k][i].StationNo < borrowSrcByMat[k][j].StationNo }) } out := make([]CallPoolRow, 0, len(rows)) for _, r := range rows { out = append(out, CallPoolRow{ StationNo: r.StationNo, MaterialCode: r.MaterialCode, MaterialName: r.MaterialName, Unit: r.Unit, SnMode: r.SnMode, ReqQty: r.ReqQty, AdjQty: r.AdjQty, SentQty: r.SentQty, ReservedQty: r.ReservedQty, AvailQty: poolAvail(r.ReqQty, r.AdjQty, r.SentQty, r.ReservedQty), BorrowAvail: borrowByMat[r.MaterialCode], BorrowSources: borrowSrcByMat[r.MaterialCode], CrossDay: r.CrossDay, PlanDates: r.PlanDates, }) } return out, nil } // AdjustPoolQty 人工改量(同工艺多工位场景:页面可调,留痕 谁/何时/原值→新值)。 // newQty 为调整后的目标总量(需求+调整);adj = 目标 − 派生需求,保持 req 为排产真值。 func (s *Service) AdjustPoolQty(ctx context.Context, stationNo int, materialCode string, newQty int, operator string) error { if stationNo <= 0 || materialCode == "" { return errors.New("工位号与物料编码必填") } if newQty < 0 { return errors.New("目标总量不能为负") } row, err := s.ctx.EntClient.CallPool.Query(). Where(callpool.StationNo(stationNo), callpool.MaterialCode(materialCode)).Only(ctx) if err != nil || row == nil { return errors.New("叫料池无该物料行") } old := row.ReqQty + row.AdjQty if newQty == old { return nil // 幂等 } adj := newQty - row.ReqQty if _, uerr := s.ctx.EntClient.CallPool.UpdateOneID(row.ID).SetAdjQty(adj).Save(ctx); uerr != nil { return uerr } s.ctx.EventLog.Write(ctx, "call.pool.adjust", "", operator, "call_pool", strconv.Itoa(stationNo)+"|"+materialCode, "叫料池人工改量", map[string]any{"stationNo": stationNo, "materialCode": materialCode, "from": old, "to": newQty, "adj": adj}) return nil } // CreateCallOrders 发起叫料:按物料行拆 N 张单;事务内行锁占用池子可用量(耗尽即止)。 // source=CALL(工位终端叫料)/ REFILL(数量不符补发,refReportNo 必填);两入口消耗同一池子。 func (s *Service) CreateCallOrders(ctx context.Context, stationNo int, items []CallItem, source, refReportNo, operator string) (int, error) { if stationNo <= 0 { return 0, errors.New("工位号无效") } if len(items) == 0 { return 0, errors.New("请添加叫料明细") } if source == "" { source = "CALL" } if source == "REFILL" && refReportNo == "" { return 0, errors.New("补发叫料必须关联数量不符单号") } st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx) if err != nil || st == nil { return 0, errors.New("工位不存在") } if st.Status == "DISABLED" { return 0, errors.New("工位已停用,不能叫料") } // 同工序候选工位(同 FlowId、启用、非本工位):本工位不足时向其借用剩余额度 sibNos := []int{} if st.FlowId > 0 { if sibs, e := s.ctx.EntClient.Station.Query(). Where(station.FlowId(st.FlowId), station.StationNoNEQ(stationNo), station.StatusEQ("ENABLED")).All(ctx); e == nil { for _, sb := range sibs { sibNos = append(sibNos, sb.StationNo) } } } sibSet := map[int]bool{} for _, n := range sibNos { sibSet[n] = true } allowCross := s.CfgInt(ctx, CfgAllowCrossDay, 1) == 1 allowBorrow := s.CfgInt(ctx, CfgAllowBorrow, 1) == 1 // 接驳台校验:目标接驳台必须属于该工位(一工位左L/右R 两个,真源=dock 表); // 停用(DISABLED)接驳台不进候选(2026-11-03 断头路补全:此前只校验归属不校验启停,停用台仍可被叫料指向) dockSet := map[string]bool{} if dks, e := s.ctx.EntClient.Dock.Query().Where(dock.StationNo(stationNo)).All(ctx); e == nil { for _, d := range dks { if d.DockCode != "" && d.Status != "DISABLED" { dockSet[d.DockCode] = true } } } // 预校验(fail-fast,减少进事务后回滚) for _, it := range items { if it.MaterialCode == "" || it.Qty <= 0 { return 0, errors.New("叫料明细的物料编码与数量必填") } if it.Dock == "" { return 0, errors.New("请选择目标接驳台") } if !dockSet[it.Dock] { return 0, fmt.Errorf("接驳台 %s 不属于本工位或已停用,请在「产线管理」确认后重选", it.Dock) } } tx, terr := s.ctx.EntClient.Tx(ctx) if terr != nil { return 0, terr } committed := false defer func() { if !committed { _ = tx.Rollback() } }() created := 0 ts := time.Now().UnixNano() borrowLogs := []borrowLogEntry{} for _, it := range items { ownRow, rerr := tx.CallPool.Query(). Where(callpool.StationNo(stationNo), callpool.MaterialCode(it.MaterialCode)). ForUpdate().First(ctx) if rerr != nil || ownRow == nil { return created, errors.New("叫料池无该物料行(该工位未排产或工艺无此物料)") } if !allowCross && ownRow.CrossDay { return created, errors.New("该料来自非今日排产,当前设置不允许跨日叫料") } // 跨工位借料(手动分配):叫料量 = 本工位自取(ownTake) + 借料(borrow);本工位先占 ownTake,借料逐源占兄弟工位 alloc := map[string]int{} ownAvail := poolAvail(ownRow.ReqQty, ownRow.AdjQty, ownRow.SentQty, ownRow.ReservedQty) borrow := it.Borrow sumB := 0 for _, amt := range borrow { sumB += amt } ownTake := it.Qty - sumB if ownTake < 0 { return created, fmt.Errorf("%s 借料分配合计 %d 超出叫料总量 %d(本工位自取 + 借料 之和 不得超过 叫料总量)", it.MaterialCode, sumB, it.Qty) } if ownTake > ownAvail { return created, fmt.Errorf("%s 本工位自取 %d 超出可用 %d(请减少自取量或增加借料)", it.MaterialCode, ownTake, ownAvail) } if ownTake > 0 { if _, uerr := tx.CallPool.UpdateOneID(ownRow.ID).AddReservedQty(ownTake).Save(ctx); uerr != nil { return created, uerr } alloc[strconv.Itoa(stationNo)] = ownTake } if sumB > 0 { if !allowBorrow { return created, fmt.Errorf("%s 自身可用 %d,系统未开启借料功能,超额叫料被拒绝(请求 %d)", it.MaterialCode, ownAvail, it.Qty) } // 严格收口(2026-11-02 主控):仅当本工位可用额度为 0(完全没料)时才允许借料;本工位仍有料则禁止借料。 if ownAvail > 0 { return created, fmt.Errorf("%s 本工位仍有可用额度 %d,无需借料;仅当本工位可用为 0 时才可借料", it.MaterialCode, ownAvail) } for src, amt := range borrow { if amt <= 0 { return created, errors.New("借料量必须为正数") } n, e := strconv.Atoi(src) if e != nil { return created, errors.New("借料工位号非法") } if n == stationNo { return created, errors.New("不能向本工位自身借料") } if !sibSet[n] { return created, fmt.Errorf("工位 %d 不在可借候选工位内(仅同工艺候选工位可借)", n) } } // 并发校验:逐源锁池子行,校验实际余量,不足则打回让工人重填 srcs := make([]string, 0, len(borrow)) for k := range borrow { srcs = append(srcs, k) } sort.Strings(srcs) for _, src := range srcs { amt := borrow[src] n, _ := strconv.Atoi(src) sr, serr := tx.CallPool.Query(). Where(callpool.StationNo(n), callpool.MaterialCode(it.MaterialCode)). ForUpdate().First(ctx) if serr != nil || sr == nil { return created, fmt.Errorf("借料工位 %d 无该物料池行", n) } if !allowCross && sr.CrossDay { return created, fmt.Errorf("借料工位 %d 该料为跨日排产,当前不允许跨日借料", n) } sa := poolAvail(sr.ReqQty, sr.AdjQty, sr.SentQty, sr.ReservedQty) if amt > sa { return created, fmt.Errorf("向工位 %d 借料 %d 超出其当前可用 %d(可能被其他工位同时借走,请重新分配)", n, amt, sa) } if _, uerr := tx.CallPool.UpdateOneID(sr.ID).AddReservedQty(amt).Save(ctx); uerr != nil { return created, uerr } alloc[src] = amt } } else if it.Qty > ownAvail { // 未借料但本工位不足(前端 max 已限制,这里兜底拦截) return created, fmt.Errorf("%s 自身可用 %d 不足(请求 %d),请开启借料或从同工序工位借料", it.MaterialCode, ownAvail, it.Qty) } reqNo := fmt.Sprintf("MR%d", ts+int64(created)) if _, cerr := tx.MaterialRequest.Create(). SetRequestNo(reqNo).SetMaterialCode(it.MaterialCode).SetMaterialName(ownRow.MaterialName). SetUnit(ownRow.Unit).SetSnMode(ownRow.SnMode).SetReqQty(float64(it.Qty)). SetStatus("PENDING").SetStationNo(stationNo).SetTargetDock(it.Dock). SetCrossDay(ownRow.CrossDay).SetSource(source).SetRefReportNo(refReportNo). SetBorrowFrom(alloc).SetNeedAgv(true).SetOperator(operator).Save(ctx); cerr != nil { return created, cerr } if d := borrowDetail(alloc, stationNo, it.MaterialCode); d != "" { borrowLogs = append(borrowLogs, borrowLogEntry{reqNo: reqNo, materialCode: it.MaterialCode, alloc: alloc}) } created++ } if cerr := tx.Commit(); cerr != nil { return created, cerr } committed = true s.ctx.EventLog.Write(ctx, "call.create", "", operator, "material_request", "", fmt.Sprintf("工位%d 发起叫料 %d 项", stationNo, created), map[string]any{"stationNo": stationNo, "count": created, "source": source, "refReportNo": refReportNo}) for _, bl := range borrowLogs { s.ctx.EventLog.Write(ctx, "call.create", "", operator, "material_request", bl.reqNo, "操作人["+operator+"] "+borrowDetail(bl.alloc, stationNo, bl.materialCode), nil) } s.notifyDashboard() return created, nil } // loadCallForUpdate 事务内锁叫料单并复核状态(返回锁后的行) func loadCallForUpdate(ctx context.Context, tx *ent.Tx, requestNo string) (*ent.MaterialRequest, error) { mr, err := tx.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).ForUpdate().Only(ctx) if err != nil || mr == nil { return nil, errors.New("叫料单不存在") } return mr, nil } // releaseReserveTx 事务内释放占用:占用 −请求量(池行缺失不阻断,历史数据容错) func releaseReserveTx(ctx context.Context, tx *ent.Tx, stationNo int, materialCode string, qty int) { row, err := tx.CallPool.Query(). Where(callpool.StationNo(stationNo), callpool.MaterialCode(materialCode)).ForUpdate().First(ctx) if err != nil || row == nil { return } _, _ = tx.CallPool.UpdateOneID(row.ID).AddReservedQty(-qty).Save(ctx) } // CancelCall 取消叫料(仅待备料):PENDING → CANCELLED,占用 −请求量。 func (s *Service) CancelCall(ctx context.Context, requestNo string, stationNo int, operator string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if stationNo > 0 && mr.StationNo != stationNo { return errors.New("只能操作本工位的叫料单") } if mr.Status != "PENDING" { return errors.New("仅待备料的叫料单可取消") } tx, terr := s.ctx.EntClient.Tx(ctx) if terr != nil { return terr } committed := false defer func() { if !committed { _ = tx.Rollback() } }() locked, lerr := loadCallForUpdate(ctx, tx, requestNo) if lerr != nil { return lerr } if locked.Status != "PENDING" { return errors.New("仅待备料的叫料单可取消") } alloc := locked.BorrowFrom if len(alloc) == 0 { alloc = map[string]int{strconv.Itoa(locked.StationNo): int(locked.ReqQty)} } for src, amt := range alloc { if srcNo, e := strconv.Atoi(src); e == nil { releaseReserveTx(ctx, tx, srcNo, locked.MaterialCode, amt) } } if _, uerr := tx.MaterialRequest.UpdateOneID(locked.ID).SetStatus("CANCELLED").Save(ctx); uerr != nil { return uerr } if cerr := tx.Commit(); cerr != nil { return cerr } committed = true cancelDesc := "叫料单取消" if d := borrowDetail(alloc, locked.StationNo, locked.MaterialCode); d != "" { cancelDesc = "操作人[" + operator + "] 取消叫料," + d } s.ctx.EventLog.Write(ctx, "call.cancel", "", operator, "material_request", requestNo, cancelDesc, map[string]any{"stationNo": locked.StationNo, "materialCode": locked.MaterialCode}) s.notifyDashboard() return nil } // SignCall 签收(仅已发货):SHIPPED → DONE。签收=确认收到,系统不再对差异。 func (s *Service) SignCall(ctx context.Context, requestNo string, stationNo int, operator string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if stationNo > 0 && mr.StationNo != stationNo { return errors.New("只能签收本工位的叫料单") } if mr.Status != "SHIPPED" { return errors.New("仅已发货的叫料单可签收") } if _, uerr := s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).SetStatus("DONE").Save(ctx); uerr != nil { return uerr } s.ctx.EventLog.Write(ctx, "call.sign", "", operator, "material_request", requestNo, "叫料单签收", map[string]any{"stationNo": mr.StationNo, "materialCode": mr.MaterialCode, "sentQty": mr.SentQty}) s.notifyDashboard() return nil } // RejectCall 仓库驳回(仅待备料):PENDING → REJECTED,占用 −请求量,理由必填(异常标记:非当日等)。 func (s *Service) RejectCall(ctx context.Context, requestNo, reason, operator string) error { if strings.TrimSpace(reason) == "" { return errors.New("驳回必须填写理由") } mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if mr.Status != "PENDING" { return errors.New("仅待备料的叫料单可驳回") } tx, terr := s.ctx.EntClient.Tx(ctx) if terr != nil { return terr } committed := false defer func() { if !committed { _ = tx.Rollback() } }() locked, lerr := loadCallForUpdate(ctx, tx, requestNo) if lerr != nil { return lerr } if locked.Status != "PENDING" { return errors.New("仅待备料的叫料单可驳回") } alloc := locked.BorrowFrom if len(alloc) == 0 { alloc = map[string]int{strconv.Itoa(locked.StationNo): int(locked.ReqQty)} } for src, amt := range alloc { if srcNo, e := strconv.Atoi(src); e == nil { releaseReserveTx(ctx, tx, srcNo, locked.MaterialCode, amt) } } if _, uerr := tx.MaterialRequest.UpdateOneID(locked.ID). SetStatus("REJECTED").SetRejectReason(strings.TrimSpace(reason)).Save(ctx); uerr != nil { return uerr } if cerr := tx.Commit(); cerr != nil { return cerr } committed = true rejectDesc := "叫料单驳回" if d := borrowDetail(alloc, locked.StationNo, locked.MaterialCode); d != "" { rejectDesc = "操作人[" + operator + "] 驳回叫料," + d } s.ctx.EventLog.Write(ctx, "call.reject", "", operator, "material_request", requestNo, rejectDesc, map[string]any{"stationNo": locked.StationNo, "materialCode": locked.MaterialCode, "reason": strings.TrimSpace(reason), "crossDay": locked.CrossDay}) s.notifyDashboard() return nil } // RequestReturn 工位申请退库(仅已发货/签收前):SHIPPED → RETURNING, // 并调 WMS 预建退库单(携带叫料单号 ref_no;仓库确认收回后回调 ConfirmReturn)。 // 整单退、不部分退;退库中额度仍占用已发,收回后回补。 func (s *Service) RequestReturn(ctx context.Context, requestNo string, stationNo int, operator string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if stationNo > 0 && mr.StationNo != stationNo { return errors.New("只能退库本工位的叫料单") } if mr.Status != "SHIPPED" { return errors.New("仅已发货(签收前)的叫料单可退库") } if s.ctx.Wms != nil { if werr := s.ctx.Wms.CreateReturnOrder(ctx, "", "", mr.MaterialCode, mr.MaterialName, "", "叫料单退库", operator, mr.StationNo, int(mr.ReqQty), mr.Unit, requestNo, mr.TargetDock, "", "agv"); werr != nil { return fmt.Errorf("通知 WMS 建退库单失败:%w", werr) } } if _, uerr := s.ctx.EntClient.MaterialRequest.UpdateOneID(mr.ID).SetStatus("RETURNING").Save(ctx); uerr != nil { return uerr } s.ctx.EventLog.Write(ctx, "call.return_request", "", operator, "material_request", requestNo, "叫料单申请退库", map[string]any{"stationNo": mr.StationNo, "materialCode": mr.MaterialCode, "qty": mr.ReqQty}) s.notifyDashboard() return nil } // CompleteCall 仓库完成备料通知(WMS 操作员点「完成备料」→ WMS 本地扣库存后调用本接口): // PENDING → SHIPPED;记实发量与 WMS 出库单号;占用 −请求量、池子已发 +实发量(差额自动释放)。 // MES 不反向调 WMS 出库(库存动作归 WMS,主控裁定 2026-10-13)。 func (s *Service) CompleteCall(ctx context.Context, requestNo string, sentQty float64, outboundNo, operator string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if mr.Status != "PENDING" { return errors.New("仅待备料的叫料单可完成备料") } actual := sentQty if actual <= 0 { actual = mr.ReqQty // 未传实发量=全发 } if actual > mr.ReqQty { return errors.New("实发量不能超过请求量") } tx, terr := s.ctx.EntClient.Tx(ctx) if terr != nil { return terr } committed := false defer func() { if !committed { _ = tx.Rollback() } }() locked, lerr := loadCallForUpdate(ctx, tx, requestNo) if lerr != nil { return lerr } if locked.Status != "PENDING" { return errors.New("仅待备料的叫料单可完成备料") } // 池子:按真实消耗来源(含借料)记账——占用 −预约量(差额自动释放)+ 已发 +实发量 alloc := locked.BorrowFrom if len(alloc) == 0 { alloc = map[string]int{strconv.Itoa(locked.StationNo): int(locked.ReqQty)} } ship := distributeAmount(int(actual), alloc) for src, amt := range ship { srcNo, e := strconv.Atoi(src) if e != nil { continue } poolRow, perr := tx.CallPool.Query(). Where(callpool.StationNo(srcNo), callpool.MaterialCode(locked.MaterialCode)). ForUpdate().First(ctx) if perr == nil && poolRow != nil { if _, uerr := tx.CallPool.UpdateOneID(poolRow.ID). AddSentQty(amt).AddReservedQty(-alloc[src]).Save(ctx); uerr != nil { return uerr } } } upd := tx.MaterialRequest.UpdateOneID(locked.ID). SetStatus("SHIPPED").SetSentQty(actual) if outboundNo != "" { upd = upd.SetOutboundNo(outboundNo) } if _, uerr := upd.Save(ctx); uerr != nil { return uerr } if cerr := tx.Commit(); cerr != nil { return cerr } committed = true completeDesc := "仓库完成备料" if d := borrowDetail(ship, locked.StationNo, locked.MaterialCode); d != "" { completeDesc = "操作人[" + operator + "] 完成备料(含借料)," + d } s.ctx.EventLog.Write(ctx, "call.complete", "", operator, "material_request", requestNo, completeDesc, map[string]any{"stationNo": locked.StationNo, "materialCode": locked.MaterialCode, "reqQty": locked.ReqQty, "sentQty": actual, "outboundNo": outboundNo}) s.notifyDashboard() // AGV 三段链(2026-11-03 定论修订):完成备料=托盘已备好在库房接驳台 → 仅写台账(hasPallet=true)。 // 废除「备料完成自动派车」:库管在 WMS 叫料队列点「送货」(DispatchCallAgv)人工触发才下发空车段。 if locked.NeedAgv && locked.TargetDock != "" { s.setDockPalletByCode(ctx, dockStoreCode, true, requestNo, requestNo) } return nil } // ConfirmReturn 仓库确认收回(退库闭环终点):RETURNING → RETURNED, // 按库管实收量回补(R18 2026-11-03 拍板:实收<应退为收货差异,按实收回补额度; // 差异落「待核」,不自动进损耗台账——以库管真实核算为准,核实为损耗后由主管走损耗登记挂工单)。 func (s *Service) ConfirmReturn(ctx context.Context, requestNo, operator string, receiveQty, receiveDiff float64, receiveNote string) error { mr, err := s.ctx.EntClient.MaterialRequest.Query(). Where(materialrequest.RequestNo(requestNo)).Only(ctx) if err != nil || mr == nil { return errors.New("叫料单不存在") } if mr.Status != "RETURNING" { return errors.New("仅退库中的叫料单可确认收回") } ret := mr.SentQty // 整单退:退库量=实发量 if receiveQty > 0 { if receiveQty > mr.SentQty { return fmt.Errorf("实收数量 %v 不能大于应退数量 %v", receiveQty, mr.SentQty) } ret = receiveQty } if receiveDiff <= 0 { // 未传差异时按应退-实收自算 receiveDiff = mr.SentQty - ret } tx, terr := s.ctx.EntClient.Tx(ctx) if terr != nil { return terr } committed := false defer func() { if !committed { _ = tx.Rollback() } }() locked, lerr := loadCallForUpdate(ctx, tx, requestNo) if lerr != nil { return lerr } if locked.Status != "RETURNING" { return errors.New("仅退库中的叫料单可确认收回") } alloc := locked.BorrowFrom if len(alloc) == 0 { alloc = map[string]int{strconv.Itoa(locked.StationNo): int(ret)} } back := distributeAmount(int(ret), alloc) for src, amt := range back { srcNo, e := strconv.Atoi(src) if e != nil { continue } poolRow, perr := tx.CallPool.Query(). Where(callpool.StationNo(srcNo), callpool.MaterialCode(locked.MaterialCode)). ForUpdate().First(ctx) if perr == nil && poolRow != nil { if _, uerr := tx.CallPool.UpdateOneID(poolRow.ID).AddSentQty(-amt).Save(ctx); uerr != nil { return uerr } } } if _, uerr := tx.MaterialRequest.UpdateOneID(locked.ID). SetStatus("RETURNED").SetReturnedQty(ret). SetReceiveQty(ret).SetReceiveDiff(receiveDiff).SetReceiveNote(receiveNote).Save(ctx); uerr != nil { return uerr } if cerr := tx.Commit(); cerr != nil { return cerr } committed = true returnDesc := "仓库确认收回,叫料单关闭" if receiveDiff > 0 { returnDesc = fmt.Sprintf("仓库确认收回:实收 %v/应退 %v,收货差异 %v(待核,不自动进损耗台账)", ret, mr.SentQty, receiveDiff) } if d := borrowDetail(back, locked.StationNo, locked.MaterialCode); d != "" { returnDesc = "操作人[" + operator + "] 确认收回(含借料回补)," + d } s.ctx.EventLog.Write(ctx, "call.return_confirm", "", operator, "material_request", requestNo, returnDesc, map[string]any{"stationNo": locked.StationNo, "materialCode": locked.MaterialCode, "returnedQty": ret, "receiveQty": ret, "receiveDiff": receiveDiff, "receiveNote": receiveNote}) // 事件驱动收口:退料收货后检查 CLOSING 班次可否置 CLOSED(下班闭环,2026-11-03) s.maybeCloseShifts(ctx) s.notifyDashboard() return nil } // ListCalls 叫料单查询(大小写不敏感;MES 后台只读视图 + 仓库队列 + 终端共用)。 func (s *Service) ListCalls(ctx context.Context, q CallQuery) ([]*ent.MaterialRequest, error) { query := s.ctx.EntClient.MaterialRequest.Query() if q.Status != "" { query = query.Where(materialrequest.Status(q.Status)) } if q.MaterialCode != "" { query = query.Where(materialrequest.MaterialCodeContainsFold(q.MaterialCode)) } if q.MaterialName != "" { query = query.Where(materialrequest.MaterialNameContainsFold(q.MaterialName)) } if q.TargetDock != "" { query = query.Where(materialrequest.TargetDockEqualFold(q.TargetDock)) } if q.Source != "" { query = query.Where(materialrequest.Source(q.Source)) } if q.RequestNo != "" { query = query.Where(materialrequest.RequestNoContainsFold(q.RequestNo)) } if q.StationNo != "" { if n, e := strconv.Atoi(q.StationNo); e == nil { query = query.Where(materialrequest.StationNo(n)) } } return query.Order(ent.Desc(materialrequest.FieldCreatedAt), ent.Desc(materialrequest.FieldID)).All(ctx) }