745 lines
25 KiB
Go
745 lines
25 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(仓库确认收回,仅签收前)。
|
||
|
||
// 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)
|
||
}
|