Files
bj_power/bj_power_mes/internal/logic/call.go
T
SunYF af554cea75 feat: 同步失败台账双向可重试 + 拧紧枪按工位配置 + 虚拟工位体系 + 去Redis与文档口径对齐
- 同步失败台账:MES/WMS 双端新增台账与页面,跨系统通知失败落台账、人工重试或标记已处理,不自动重传;重试前先判对端终态;叫料、配送、出库回写失败提示指向台账;补幂等建表脚本与菜单权限。
- 拧紧枪:新增按工位配置页,展示控制器地址与三把枪通道号(仅供查看,不参与采集校验);「允许手填」由全局开关改为每工位开关,关闭时校验该工位已配控制器;终端启动/登录上报配置并按本工位拉取,扭矩手填框按本工位置灰;补全局值迁移到各工位的脚本。
- 工位体系:终端未配置工位号时登录页可选(含虚拟工位),固定工位模式保留;虚拟/线下位不叫料、不退料、不作转产目标,未采集绑定放行并说明原因;叫料期望接驳台改为选填。
- AGV与出库:补「出库单已送达」回写;空车回充、接驳台传感器失联、配送状态更新失败均落预警或留痕并提示人工核对;人工出库不引入送达状态;出库单支持目标工位/接驳台并扩展导出列。
- 基础设施:看板缓存由Redis改为MES进程内实现,文档与启动脚本同步去Redis;扫码监听支持多地址、端口被占自动降级;PLC对账与工位报警在MES不可达时降级放行并留日志。
- 文档与帮助:案例与部署手册按实测订正(工位绑定、菜单名称、补料由班组长代提、菜单覆盖对照、虚拟工位);迁移脚本改为本地即时执行并登记7个已执行脚本;三端页面帮助改为「业务/操作/影响范围/后果」四要素。
- 测试:新增独立Go模块,按三个业务场景做真实HTTP与真实写库的流水测试,含运行报告。
2026-11-09 18:58:47 +08:00

1074 lines
40 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 口径生效)。
// 业务口径(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("请添加叫料明细")
}
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})
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)
}
} 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)
}