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