Files
bj_power/bj_power_mes/internal/logic/call.go
T
SunYF 1e92b2a596 feat: 核心业务实体扩充(混产模板/产品BOM/试制记录)、WMS 库存检验增强与前端通用能力
- MES 新增实体:混产模板、产品BOM、产品工艺物料、试制记录(schema + ent 生成码 + logic/handler/前端页)
- WMS 实体增强:检验记录、库存、半成品重构;新增序列号库存与短缺代报
- AGV 与产能:AGV 手动点位与链路、物料守卫、短缺预测、原因字典
- 前端通用能力:新增下一步引导组件 NextStepBar,统一帮助文档/布局/请求拦截与操作列
- 工位终端:界面与各 handler 调整(api/store/绑定/PLC/拧紧/上报等)
- 配置与文档:更新 mes-api.yaml、WMS README 及案例/产线API/问题记录/项目说明/流程说明
2026-11-15 12:17:39 +08:00

1116 lines
42 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/agvtask"
"bj_power_mes/ent/callpool"
"bj_power_mes/ent/dailyplan"
"bj_power_mes/ent/dock"
"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, merr := s.MaterialsByFlowForWO(ctx, s.ctx.EntClient, wo, flowIdsOf(items))
if merr != nil {
continue
}
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 口径生效)。
// 业务口径(2026-11-06 拍板):池行按物料合并(跨工单聚合),默认带出当前工位所有工单物料、
// 可勾选部分量提交——分次补叫是设计功能不是手误;一次提交=一个叫料包(同 package_no),
// 一包可拆多张配送单分趟送。
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("请添加叫料明细")
}
// 2026-11-13 拍板:叫料单只服务物料,成品/在制品不得进入物料单据(后端硬守卫,防绕过前端)。
codes := make([]string, 0, len(items))
for _, it := range items {
codes = append(codes, it.MaterialCode)
}
if err := s.AssertMaterialOnly(ctx, codes); err != nil {
return 0, err
}
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("工位已停用,不能叫料")
}
// 2026-11-09 拍板:虚拟/无接驳台工位不支持叫料——工位无启用 line 接驳台(=虚拟/线下位,判据同
// 2026-11-08 B2 报工绑定拦截 stationHasEnabledLineDock)时拒绝,防 API 直调产生无台可送的叫料单。
if !s.stationHasEnabledLineDock(ctx, s.ctx.EntClient, stationNo) {
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
}
}
// 2026-11-06 强提风险标记:PLC 离线强行提交叫料 → 目标点位打「强提」标记 + 推预警,
// 后续该点位派车要求人工二次确认(preDispatchPointCheck 拦截,确认后放行并清标)。
if source == "CALL" && force {
codes := []string{}
seen := map[string]bool{}
for _, it := range items {
if it.Dock != "" && !seen[it.Dock] {
seen[it.Dock] = true
codes = append(codes, it.Dock)
}
}
if dks, e := s.ctx.EntClient.Dock.Query().Where(dock.StationNo(stationNo)).All(ctx); e == nil {
for _, d := range dks {
if d.Status != "DISABLED" && d.DockCode != "" && !seen[d.DockCode] {
seen[d.DockCode] = true
codes = append(codes, d.DockCode)
}
}
}
s.MarkForcePickOnCallOrders(ctx, codes, "强提叫料 工位"+strconv.Itoa(stationNo))
}
// 接驳台降级为期望接驳台(可空);填写时仍须属于本工位且启用
// 预校验(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})
// 2026-11-14 用户拍板(工位接驳台专用,签收即放行):工人点「签收」后自动对本工位
// 到位待令的 CALL 链运输段执行卸货放行(托盘上台、车置空、空车回充、配送单回写已送达),
// 工人无需再去 MES 后台点「卸货完成并放行」。联动失败不阻断签收(车未到等场景落日志,
// 由人工在 MES「AGV配送」页兜底)。
s.releaseArrivedTransportOnSign(ctx, mr.StationNo, requestNo, operator)
s.notifyDashboard()
return nil
}
// releaseArrivedTransportOnSign 签收联动卸货放行(2026-11-14 用户拍板)。
// 反查口径按物理位置:本工位接驳台(dock.station_no)上停着的「ARRIVED + TRANSPORT + CALL」任务
// 就是要卸的货。任务表的 related_request_no 存的是 BizNo(新配送单链路=配送单号、旧直派链路=叫料单号),
// 与签收单号不是一回事,不能按单号反查。
func (s *Service) releaseArrivedTransportOnSign(ctx context.Context, stationNo int, requestNo, operator string) {
if stationNo <= 0 {
return
}
docks, derr := s.ctx.EntClient.Dock.Query().Where(dock.StationNoEQ(stationNo)).All(ctx)
if derr != nil || len(docks) == 0 {
return
}
codes := make([]string, 0, len(docks))
for _, d := range docks {
codes = append(codes, d.DockCode)
}
tasks, terr := s.ctx.EntClient.AgvTask.Query().
Where(
agvtask.StatusEQ("ARRIVED"),
agvtask.KindEQ("TRANSPORT"),
agvtask.BizTypeEQ("CALL"),
agvtask.TargetDockIn(codes...),
).All(ctx)
if terr != nil {
return
}
for _, t := range tasks {
if rerr := s.ConfirmUnloadRelease(ctx, t.TaskNo, operator); rerr != nil {
s.ctx.EventLog.Write(ctx, "call.sign_agv_release_failed", operator, "", "agv_task", t.TaskNo,
"签收联动卸货放行失败(请到 MES「AGV配送」人工放行):"+rerr.Error(), nil)
continue
}
s.ctx.EventLog.Write(ctx, "call.sign_agv_release", operator, "", "agv_task", t.TaskNo,
"工位签收联动卸货放行(叫料单 "+requestNo+"),AGV 自动回充", 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)
}
} else {
// 配置缺失(2026-11-08):不拒绝本地退库,但必须落预警中心,避免形成
// 无对应 WMS 单据的孤儿 RETURNING 状态而不被业务人员察觉。
_ = s.CreateAlert(ctx, "wms_not_configured", "警告", requestNo,
"叫料单 "+requestNo+" 申请退库时 WMS 未配置,已跳过创建 WMS 退库单(本地仍置 RETURNING),请人工跟进")
}
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)
}