Files
bj_power/bj_power_mes/internal/logic/call.go
T
SunYF 46fcb59079 feat: 退料闭环定稿(损耗台账/备料清单/退料AGV自动派车/剩余量参考)+ 工位托盘守卫
- MES 新增损耗台账 loss_ledger,差异确认损耗接口 ConfirmReceiveLoss(按工单归集)
- 备料清单 preparation:MES 按 日计划×工单×工位×物料 实时计算,WMS 只读展示 PreparationList
- 退料闭环:N5 工位托盘守卫(未完成禁止退料)、退料 AGV 自动派车(JBT21 空位判定 + 托盘回收链路)、退料参考剩余量接口(应剩余=实备-已耗-已退-已损)
- 新增 AGV 车辆状态表 agv_vehicle_state 及查询
- 整合接驳台/叫料池/库存锁既有闭环,清理 sql 目录注释生成脚本与 catalog,更新文档
2026-11-04 19:06:03 +08:00

1013 lines
36 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"
"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)
}