Files
bj_power/bj_power_mes/internal/logic/call.go
T

745 lines
25 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(仓库确认收回,仅签收前)。
// 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"`
CrossDay bool `json:"crossDay"`
PlanDates string `json:"planDates"`
}
// CallItem 叫料明细行:一个物料 + 一个量 + 一个目标接驳台 = 一张叫料单 = 一个托盘 = 一次配送
type CallItem struct {
MaterialCode string `json:"materialCode"`
Qty int `json:"qty"`
Dock string `json:"dock"`
}
// 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
}
// 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
}
need := int(math.Ceil(float64(q) * fm.UnitQty * (1 + fm.LossRate/100)))
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
}
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),
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("工位已停用,不能叫料")
}
allowCross := s.CfgInt(ctx, CfgAllowCrossDay, 1) == 1
// 接驳台校验:目标接驳台必须属于该工位(一工位左L/右R 两个,真源=dock 表)
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 != "" {
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, errors.New("该工位无此接驳台:" + 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()
for _, it := range items {
row, rerr := tx.CallPool.Query().
Where(callpool.StationNo(stationNo), callpool.MaterialCode(it.MaterialCode)).
ForUpdate().First(ctx)
if rerr != nil || row == nil {
return created, errors.New("叫料池无该物料行(该工位未排产或工艺无此物料)")
}
if !allowCross && row.CrossDay {
return created, errors.New("该料来自非今日排产,当前设置不允许跨日叫料")
}
avail := poolAvail(row.ReqQty, row.AdjQty, row.SentQty, row.ReservedQty)
if it.Qty > avail {
return created, fmt.Errorf("%s 可用量不足(可用 %d,请求 %d)", it.MaterialCode, avail, it.Qty)
}
if _, uerr := tx.CallPool.UpdateOneID(row.ID).AddReservedQty(it.Qty).Save(ctx); uerr != nil {
return created, uerr
}
reqNo := fmt.Sprintf("MR%d", ts+int64(created))
if _, cerr := tx.MaterialRequest.Create().
SetRequestNo(reqNo).SetMaterialCode(it.MaterialCode).SetMaterialName(row.MaterialName).
SetUnit(row.Unit).SetSnMode(row.SnMode).SetReqQty(float64(it.Qty)).
SetStatus("PENDING").SetStationNo(stationNo).SetTargetDock(it.Dock).
SetCrossDay(row.CrossDay).SetSource(source).SetRefReportNo(refReportNo).
SetNeedAgv(true).SetOperator(operator).Save(ctx); cerr != nil {
return created, cerr
}
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})
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("仅待备料的叫料单可取消")
}
releaseReserveTx(ctx, tx, locked.StationNo, locked.MaterialCode, int(locked.ReqQty))
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
s.ctx.EventLog.Write(ctx, "call.cancel", "", operator, "material_request", requestNo,
"叫料单取消", 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("仅待备料的叫料单可驳回")
}
releaseReserveTx(ctx, tx, locked.StationNo, locked.MaterialCode, int(locked.ReqQty))
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
s.ctx.EventLog.Write(ctx, "call.reject", "", operator, "material_request", requestNo,
"叫料单驳回", 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); 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("仅待备料的叫料单可完成备料")
}
// 池子:占用 −请求量(差额自动释放)+ 已发 +实发量
poolRow, perr := tx.CallPool.Query().
Where(callpool.StationNo(locked.StationNo), callpool.MaterialCode(locked.MaterialCode)).
ForUpdate().First(ctx)
if perr == nil && poolRow != nil {
if _, uerr := tx.CallPool.UpdateOneID(poolRow.ID).
AddSentQty(int(actual)).AddReservedQty(-int(locked.ReqQty)).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
s.ctx.EventLog.Write(ctx, "call.complete", "", operator, "material_request", requestNo,
"仓库完成备料", map[string]any{"stationNo": locked.StationNo, "materialCode": locked.MaterialCode,
"reqQty": locked.ReqQty, "sentQty": actual, "outboundNo": outboundNo})
s.notifyDashboard()
// AGV 自动派车(best-effort,2026-10-14 迁 MES):由 MES 调度海康 RCS,失败仅记日志不阻断叫料完成
if locked.NeedAgv && locked.TargetDock != "" {
if derr := s.DispatchAgvForCall(ctx, locked, operator); derr != nil {
s.ctx.EventLog.Write(ctx, "agv.dispatch.fail", "", operator, "material_request", requestNo,
"叫料完成备料自动派车失败", map[string]any{"err": derr.Error()})
}
}
return nil
}
// ConfirmReturn 仓库确认收回(退库闭环终点):RETURNING → RETURNED,
// 退库量=实发量(整单退);池子已发 −退库量(额度回补)。
func (s *Service) ConfirmReturn(ctx context.Context, requestNo, 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 != "RETURNING" {
return errors.New("仅退库中的叫料单可确认收回")
}
ret := mr.SentQty // 整单退:退库量=实发量
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("仅退库中的叫料单可确认收回")
}
poolRow, perr := tx.CallPool.Query().
Where(callpool.StationNo(locked.StationNo), callpool.MaterialCode(locked.MaterialCode)).
ForUpdate().First(ctx)
if perr == nil && poolRow != nil {
if _, uerr := tx.CallPool.UpdateOneID(poolRow.ID).AddSentQty(-int(ret)).Save(ctx); uerr != nil {
return uerr
}
}
if _, uerr := tx.MaterialRequest.UpdateOneID(locked.ID).
SetStatus("RETURNED").SetReturnedQty(ret).Save(ctx); uerr != nil {
return uerr
}
if cerr := tx.Commit(); cerr != nil {
return cerr
}
committed = true
s.ctx.EventLog.Write(ctx, "call.return_confirm", "", operator, "material_request", requestNo,
"仓库确认收回,叫料单关闭", map[string]any{"stationNo": locked.StationNo,
"materialCode": locked.MaterialCode, "returnedQty": ret})
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)
}