Files
bj_power/bj_power_mes/internal/logic/call.go
T
SunYF 1d1dc1bdd8 按模块说明
一、MES — 叫料单扩展(schema + 逻辑)​

material_request 新增字段:packageNo(叫料包号,一次提交=一包)、callDate(叫料日,默认当天)、planBreakdown(jsonb,工单×排产日明细 []CallPlanBreakdown);targetDock 语义降级为"期望接驳台(可空,配送时 WMS 确定实际台)"。
新增 internal/logic/call_plan.go:实时计算「叫料需求明细(工单×排产日×物料)」,派生两类提示(当日剩余未叫 / 跨日量明细),不落库、不拦提交;接驳台空台校验 EnsureStationDocksEmpty、托盘回库 DispatchPalletReturnManual、人工清台 ClearDockLedger、配送单派车 DispatchDeliveryAgv、工位物料明细 StationMaterialDetail。
新增 internal/handler/production/call_pkg.go:8 个 MES 内部端点(X-API-TOKEN 网关),供 WMS 调用——叫料需求明细、按包查单、接驳台状态、托盘回库、人工清台、配送单派车、叫料池原始行、工位物料明细、WMS 代叫料。
internal/handler/production/call.go、internal/logic/call.go、agv.go、qty_report.go、routes_production.go、wmsclient/client.go、db.go 同步接入上述逻辑。
二、WMS — 配送单(新功能,叫料与送料彻底拆开)​

新增 schema/delivery_order.go + delivery_order_item.go 及 ent 生成代码:delivery_order(PENDING→DISPATCHED→DONE / CANCELLED,一单=一次托盘配送)、delivery_order_item(配送物料明细快照:工单/工艺/排产日)。
新增 internal/handler/delivery.go + 路由 + DeliveryOrders.vue 页面(仓储作业 → 配送单)。
mesclient/client.go 扩展:MES 叫料单结构补 packageNo/callDate/workOrderNo/planBreakdown,新增 PoolRow/DockPalletState/DeliveryAgvItem/getJSON 等。
CallQueue.vue:按叫料包展示,新增「代叫料」「建配送单」按钮与对话框;出库单回写所属配送单号(outbound_order 加字段);AGV 派送改由配送单驱动。
三、工位终端 — 叫料体验升级

MaterialPanel.vue:新增「本工位物料明细」卡(工艺物料全集×工位账四数,量为 0 也显示);叫料改为「叫料包」模式(默认当天、可勾选分批、可选其他排产日、期望接驳台可空),新增叫料日选择器、两条提示横幅(当日剩余未叫 / 跨日量明细)、托盘回库按钮。
InspectPanel.vue/Main.vue/OnlinePanel.vue/OfflinePanel.vue/WorkPanel.vue/SyncQueueDialog.vue/api/index.js/internal/handler/line.go/routes.go 同步接入接驳台状态、托盘回库、下班双台空台校验等。
web/static/index.html 构建刷新。
四、文档

案例.md:重写第 5/6/8/9 节与新「配送单」流程,补「模拟模式跳过接驳台校验」说明,库管员菜单加「配送单」;并修正"本单箱体"等措辞歧义。
客户问题.md:同步本轮拍板口径。
五、构建产物 / 同步

多个 MES 前端页面(.vue)随本次改动统一重新构建刷新;ent 生成代码(MES material_request、WMS delivery_order/outbound_order 相关)随 schema 更新重新生成。
2026-11-05 19:18:18 +08:00

1040 lines
38 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 张单(2026-11-05 拍板:一次提交=一个叫料包,
// 同批所有单赋同一 package_no;callDate=所选排产日默认当天);事务内行锁占用池子可用量(耗尽即止)。
// source=CALL(工位终端叫料/WMS 代叫料)/ REFILL(数量不符补发,refReportNo 必填);两入口消耗同一池子。
// 接驳台降级为「期望接驳台」(可空,配送时 WMS 确定实际接驳台);提交时校验两接驳台都为空
// (force=true 为 PLC 离线降级强提,仅 CALL 口径生效)。
func (s *Service) CreateCallOrders(ctx context.Context, stationNo int, items []CallItem, source, refReportNo, operator string, callDate string, force bool) (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
}
}
}
// 2026-11-05 拍板:两个接驳台都为空才能叫料(提交时校验;PLC 离线降级=提示后可强行提交)
if source == "CALL" && !force {
if derr := s.EnsureStationDocksEmpty(ctx, stationNo); derr != nil {
return 0, derr
}
}
// 接驳台降级为期望接驳台(可空);填写时仍须属于本工位且启用
// 预校验(fail-fast,减少进事务后回滚)
for _, it := range items {
if it.MaterialCode == "" || it.Qty <= 0 {
return 0, errors.New("叫料明细的物料编码与数量必填")
}
if it.Dock != "" && !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()
// 叫料包(2026-11-05 拍板):同批提交的所有单赋同一包号;存量单为空=单包
packageNo := fmt.Sprintf("PK%d-%d", stationNo, ts)
if callDate == "" {
callDate = time.Now().Format("2006-01-02")
}
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))
// 工单×排产日明细拆分(2026-11-05 拍板:物料挂工单;池聚合层不动,明细层补留)
breakdown := s.splitPlanBreakdown(ctx, stationNo, it.MaterialCode, it.Qty, callDate)
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).
SetPackageNo(packageNo).SetCallDate(callDate).SetPlanBreakdown(breakdown).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 项(包 %s,叫料日 %s)", stationNo, created, packageNo, callDate),
map[string]any{"stationNo": stationNo, "count": created, "source": source,
"refReportNo": refReportNo, "packageNo": packageNo, "callDate": callDate})
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
}
// ListMaterialRequestsByPackage 按叫料包号查叫料单(WMS 建配送单数据源;
// 含工单×排产明细 planBreakdown 与出库单号;按创建时间升序)。
func (s *Service) ListMaterialRequestsByPackage(ctx context.Context, packageNo string) ([]*ent.MaterialRequest, error) {
if packageNo == "" {
return nil, errors.New("缺少包号")
}
return s.ctx.EntClient.MaterialRequest.Query().
Where(materialrequest.PackageNo(packageNo)).
Order(ent.Asc(materialrequest.FieldCreatedAt)).All(ctx)
}
// 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)
}