一、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 更新重新生成。
499 lines
17 KiB
Go
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...)
|
|
}
|