Files
bj_power/bj_power_wms/ent/hook/hook.go
T
SunYF 1d1dc1bdd8 按模块说明
一、MES — 叫料单扩展(schema + 逻辑)​

material_request 新增字段:packageNo(叫料包号,一次提交=一包)、callDate(叫料日,默认当天)、planBreakdown(jsonb,工单×排产日明细 []CallPlanBreakdown);targetDock 语义降级为"期望接驳台(可空,配送时 WMS 确定实际台)"。
新增 internal/logic/call_plan.go:实时计算「叫料需求明细(工单×排产日×物料)」,派生两类提示(当日剩余未叫 / 跨日量明细),不落库、不拦提交;接驳台空台校验 EnsureStationDocksEmpty、托盘回库 DispatchPalletReturnManual、人工清台 ClearDockLedger、配送单派车 DispatchDeliveryAgv、工位物料明细 StationMaterialDetail。
新增 internal/handler/production/call_pkg.go:8 个 MES 内部端点(X-API-TOKEN 网关),供 WMS 调用——叫料需求明细、按包查单、接驳台状态、托盘回库、人工清台、配送单派车、叫料池原始行、工位物料明细、WMS 代叫料。
internal/handler/production/call.go、internal/logic/call.go、agv.go、qty_report.go、routes_production.go、wmsclient/client.go、db.go 同步接入上述逻辑。
二、WMS — 配送单(新功能,叫料与送料彻底拆开)​

新增 schema/delivery_order.go + delivery_order_item.go 及 ent 生成代码:delivery_order(PENDING→DISPATCHED→DONE / CANCELLED,一单=一次托盘配送)、delivery_order_item(配送物料明细快照:工单/工艺/排产日)。
新增 internal/handler/delivery.go + 路由 + DeliveryOrders.vue 页面(仓储作业 → 配送单)。
mesclient/client.go 扩展:MES 叫料单结构补 packageNo/callDate/workOrderNo/planBreakdown,新增 PoolRow/DockPalletState/DeliveryAgvItem/getJSON 等。
CallQueue.vue:按叫料包展示,新增「代叫料」「建配送单」按钮与对话框;出库单回写所属配送单号(outbound_order 加字段);AGV 派送改由配送单驱动。
三、工位终端 — 叫料体验升级

MaterialPanel.vue:新增「本工位物料明细」卡(工艺物料全集×工位账四数,量为 0 也显示);叫料改为「叫料包」模式(默认当天、可勾选分批、可选其他排产日、期望接驳台可空),新增叫料日选择器、两条提示横幅(当日剩余未叫 / 跨日量明细)、托盘回库按钮。
InspectPanel.vue/Main.vue/OnlinePanel.vue/OfflinePanel.vue/WorkPanel.vue/SyncQueueDialog.vue/api/index.js/internal/handler/line.go/routes.go 同步接入接驳台状态、托盘回库、下班双台空台校验等。
web/static/index.html 构建刷新。
四、文档

案例.md:重写第 5/6/8/9 节与新「配送单」流程,补「模拟模式跳过接驳台校验」说明,库管员菜单加「配送单」;并修正"本单箱体"等措辞歧义。
客户问题.md:同步本轮拍板口径。
五、构建产物 / 同步

多个 MES 前端页面(.vue)随本次改动统一重新构建刷新;ent 生成代码(MES material_request、WMS delivery_order/outbound_order 相关)随 schema 更新重新生成。
2026-11-05 19:18:18 +08:00

499 lines
17 KiB
Go

// Code generated by ent, DO NOT EDIT.
package hook
import (
"bj_power_wms/ent"
"context"
"fmt"
)
// The AlertFunc type is an adapter to allow the use of ordinary
// function as Alert mutator.
type AlertFunc func(context.Context, *ent.AlertMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f AlertFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.AlertMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AlertMutation", m)
}
// The AlertRuleFunc type is an adapter to allow the use of ordinary
// function as AlertRule mutator.
type AlertRuleFunc func(context.Context, *ent.AlertRuleMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f AlertRuleFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.AlertRuleMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AlertRuleMutation", m)
}
// The AttachmentFunc type is an adapter to allow the use of ordinary
// function as Attachment mutator.
type AttachmentFunc func(context.Context, *ent.AttachmentMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f AttachmentFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.AttachmentMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AttachmentMutation", m)
}
// The BackupRecordFunc type is an adapter to allow the use of ordinary
// function as BackupRecord mutator.
type BackupRecordFunc func(context.Context, *ent.BackupRecordMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f BackupRecordFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.BackupRecordMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.BackupRecordMutation", m)
}
// The DeliveryOrderFunc type is an adapter to allow the use of ordinary
// function as DeliveryOrder mutator.
type DeliveryOrderFunc func(context.Context, *ent.DeliveryOrderMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f DeliveryOrderFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.DeliveryOrderMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DeliveryOrderMutation", m)
}
// The DeliveryOrderItemFunc type is an adapter to allow the use of ordinary
// function as DeliveryOrderItem mutator.
type DeliveryOrderItemFunc func(context.Context, *ent.DeliveryOrderItemMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f DeliveryOrderItemFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.DeliveryOrderItemMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.DeliveryOrderItemMutation", m)
}
// The EventLogFunc type is an adapter to allow the use of ordinary
// function as EventLog mutator.
type EventLogFunc func(context.Context, *ent.EventLogMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f EventLogFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.EventLogMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.EventLogMutation", m)
}
// The InboundDetailFunc type is an adapter to allow the use of ordinary
// function as InboundDetail mutator.
type InboundDetailFunc func(context.Context, *ent.InboundDetailMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f InboundDetailFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.InboundDetailMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.InboundDetailMutation", m)
}
// The InboundOrderFunc type is an adapter to allow the use of ordinary
// function as InboundOrder mutator.
type InboundOrderFunc func(context.Context, *ent.InboundOrderMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f InboundOrderFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.InboundOrderMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.InboundOrderMutation", m)
}
// The InspectionRecordFunc type is an adapter to allow the use of ordinary
// function as InspectionRecord mutator.
type InspectionRecordFunc func(context.Context, *ent.InspectionRecordMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f InspectionRecordFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.InspectionRecordMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.InspectionRecordMutation", m)
}
// The InventoryFunc type is an adapter to allow the use of ordinary
// function as Inventory mutator.
type InventoryFunc func(context.Context, *ent.InventoryMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f InventoryFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.InventoryMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.InventoryMutation", m)
}
// The InventoryLockFunc type is an adapter to allow the use of ordinary
// function as InventoryLock mutator.
type InventoryLockFunc func(context.Context, *ent.InventoryLockMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f InventoryLockFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.InventoryLockMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.InventoryLockMutation", m)
}
// The MaterialFunc type is an adapter to allow the use of ordinary
// function as Material mutator.
type MaterialFunc func(context.Context, *ent.MaterialMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f MaterialFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.MaterialMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MaterialMutation", m)
}
// The MaterialDemandFunc type is an adapter to allow the use of ordinary
// function as MaterialDemand mutator.
type MaterialDemandFunc func(context.Context, *ent.MaterialDemandMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f MaterialDemandFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.MaterialDemandMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MaterialDemandMutation", m)
}
// The OrderMaterialLedgerFunc type is an adapter to allow the use of ordinary
// function as OrderMaterialLedger mutator.
type OrderMaterialLedgerFunc func(context.Context, *ent.OrderMaterialLedgerMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f OrderMaterialLedgerFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.OrderMaterialLedgerMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.OrderMaterialLedgerMutation", m)
}
// The OutboundDetailFunc type is an adapter to allow the use of ordinary
// function as OutboundDetail mutator.
type OutboundDetailFunc func(context.Context, *ent.OutboundDetailMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f OutboundDetailFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.OutboundDetailMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.OutboundDetailMutation", m)
}
// The OutboundOrderFunc type is an adapter to allow the use of ordinary
// function as OutboundOrder mutator.
type OutboundOrderFunc func(context.Context, *ent.OutboundOrderMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f OutboundOrderFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.OutboundOrderMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.OutboundOrderMutation", m)
}
// The PermissionFunc type is an adapter to allow the use of ordinary
// function as Permission mutator.
type PermissionFunc func(context.Context, *ent.PermissionMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f PermissionFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.PermissionMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.PermissionMutation", m)
}
// The ReturnOrderFunc type is an adapter to allow the use of ordinary
// function as ReturnOrder mutator.
type ReturnOrderFunc func(context.Context, *ent.ReturnOrderMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f ReturnOrderFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.ReturnOrderMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ReturnOrderMutation", m)
}
// The RoleFunc type is an adapter to allow the use of ordinary
// function as Role mutator.
type RoleFunc func(context.Context, *ent.RoleMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f RoleFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.RoleMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.RoleMutation", m)
}
// The SemiFinishedFunc type is an adapter to allow the use of ordinary
// function as SemiFinished mutator.
type SemiFinishedFunc func(context.Context, *ent.SemiFinishedMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f SemiFinishedFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.SemiFinishedMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SemiFinishedMutation", m)
}
// The StocktakeItemFunc type is an adapter to allow the use of ordinary
// function as StocktakeItem mutator.
type StocktakeItemFunc func(context.Context, *ent.StocktakeItemMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f StocktakeItemFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.StocktakeItemMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.StocktakeItemMutation", m)
}
// The StocktakeOrderFunc type is an adapter to allow the use of ordinary
// function as StocktakeOrder mutator.
type StocktakeOrderFunc func(context.Context, *ent.StocktakeOrderMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f StocktakeOrderFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.StocktakeOrderMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.StocktakeOrderMutation", m)
}
// The SysConfigFunc type is an adapter to allow the use of ordinary
// function as SysConfig mutator.
type SysConfigFunc func(context.Context, *ent.SysConfigMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f SysConfigFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.SysConfigMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SysConfigMutation", m)
}
// The UserFunc type is an adapter to allow the use of ordinary
// function as User mutator.
type UserFunc func(context.Context, *ent.UserMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f UserFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.UserMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserMutation", m)
}
// The ZoneFunc type is an adapter to allow the use of ordinary
// function as Zone mutator.
type ZoneFunc func(context.Context, *ent.ZoneMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f ZoneFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if mv, ok := m.(*ent.ZoneMutation); ok {
return f(ctx, mv)
}
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.ZoneMutation", m)
}
// Condition is a hook condition function.
type Condition func(context.Context, ent.Mutation) bool
// And groups conditions with the AND operator.
func And(first, second Condition, rest ...Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
if !first(ctx, m) || !second(ctx, m) {
return false
}
for _, cond := range rest {
if !cond(ctx, m) {
return false
}
}
return true
}
}
// Or groups conditions with the OR operator.
func Or(first, second Condition, rest ...Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
if first(ctx, m) || second(ctx, m) {
return true
}
for _, cond := range rest {
if cond(ctx, m) {
return true
}
}
return false
}
}
// Not negates a given condition.
func Not(cond Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
return !cond(ctx, m)
}
}
// HasOp is a condition testing mutation operation.
func HasOp(op ent.Op) Condition {
return func(_ context.Context, m ent.Mutation) bool {
return m.Op().Is(op)
}
}
// HasAddedFields is a condition validating `.AddedField` on fields.
func HasAddedFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if _, exists := m.AddedField(field); !exists {
return false
}
for _, field := range fields {
if _, exists := m.AddedField(field); !exists {
return false
}
}
return true
}
}
// HasClearedFields is a condition validating `.FieldCleared` on fields.
func HasClearedFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if exists := m.FieldCleared(field); !exists {
return false
}
for _, field := range fields {
if exists := m.FieldCleared(field); !exists {
return false
}
}
return true
}
}
// HasFields is a condition validating `.Field` on fields.
func HasFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if _, exists := m.Field(field); !exists {
return false
}
for _, field := range fields {
if _, exists := m.Field(field); !exists {
return false
}
}
return true
}
}
// If executes the given hook under condition.
//
// hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
func If(hk ent.Hook, cond Condition) ent.Hook {
return func(next ent.Mutator) ent.Mutator {
return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if cond(ctx, m) {
return hk(next).Mutate(ctx, m)
}
return next.Mutate(ctx, m)
})
}
}
// On executes the given hook only for the given operation.
//
// hook.On(Log, ent.Delete|ent.Create)
func On(hk ent.Hook, op ent.Op) ent.Hook {
return If(hk, HasOp(op))
}
// Unless skips the given hook only for the given operation.
//
// hook.Unless(Log, ent.Update|ent.UpdateOne)
func Unless(hk ent.Hook, op ent.Op) ent.Hook {
return If(hk, Not(HasOp(op)))
}
// FixedError is a hook returning a fixed error.
func FixedError(err error) ent.Hook {
return func(ent.Mutator) ent.Mutator {
return ent.MutateFunc(func(context.Context, ent.Mutation) (ent.Value, error) {
return nil, err
})
}
}
// Reject returns a hook that rejects all operations that match op.
//
// func (T) Hooks() []ent.Hook {
// return []ent.Hook{
// Reject(ent.Delete|ent.Update),
// }
// }
func Reject(op ent.Op) ent.Hook {
hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
return On(hk, op)
}
// Chain acts as a list of hooks and is effectively immutable.
// Once created, it will always hold the same set of hooks in the same order.
type Chain struct {
hooks []ent.Hook
}
// NewChain creates a new chain of hooks.
func NewChain(hooks ...ent.Hook) Chain {
return Chain{append([]ent.Hook(nil), hooks...)}
}
// Hook chains the list of hooks and returns the final hook.
func (c Chain) Hook() ent.Hook {
return func(mutator ent.Mutator) ent.Mutator {
for i := len(c.hooks) - 1; i >= 0; i-- {
mutator = c.hooks[i](mutator)
}
return mutator
}
}
// Append extends a chain, adding the specified hook
// as the last ones in the mutation flow.
func (c Chain) Append(hooks ...ent.Hook) Chain {
newHooks := make([]ent.Hook, 0, len(c.hooks)+len(hooks))
newHooks = append(newHooks, c.hooks...)
newHooks = append(newHooks, hooks...)
return Chain{newHooks}
}
// Extend extends a chain, adding the specified chain
// as the last ones in the mutation flow.
func (c Chain) Extend(chain Chain) Chain {
return c.Append(chain.hooks...)
}