diff --git a/bj_power_dashboard/src/mock.ts b/bj_power_dashboard/src/mock.ts index dabdef9..0d5bb81 100644 --- a/bj_power_dashboard/src/mock.ts +++ b/bj_power_dashboard/src/mock.ts @@ -91,12 +91,12 @@ function buildDemoPoints() { dock: (() => { const arr = Array.from({ length: 20 }, (_, i) => { const g = Math.floor(i / 2) + 1; - // 左右按操作员朝向区分(2026-11-03 拍板):上排奇数工位 左=L;下排偶数工位 2/4/6/8/10 - // 操作员面向主线,其左手边=地图右(偶数位=L)——与 dock.side 字段口径一致。 + // 左右互换(2026-11-03 拍板):偶数工位 地图左=GxR、地图右=GxL;奇数工位 地图左=GxL。 const s = g % 2 === 1 ? (i % 2 === 0 ? 'L' : 'R') : (i % 2 === 0 ? 'R' : 'L'); - return { code: `G${g}${s}`, has: dockHas.has(`G${g}${s}`) }; + const code = `G${g}${s}`; + return { code, label: `工位${g}${s === 'L' ? '左' : '右'}`, has: dockHas.has(code) }; }); - arr.push({ code: 'JBT21', has: dockHas.has('JBT21') }); + arr.push({ code: 'JBT21', label: '库房接驳台', has: dockHas.has('JBT21') }); return arr; })(), transit: [{ src: 'G5', tgt: 'C7' }], @@ -175,7 +175,7 @@ function buildTraceItem(index: number, doneMinutesAgo: number): TraceItem { export function getDemoData(): DashboardData { const now = new Date(); - // 当前订单:工期 26 天,今天处于中段,剩余天数按真实日期动态计算 + // 当前工单:工期 26 天,今天处于中段,剩余天数按真实日期动态计算 const planStart = addDays(now, -10); const planEnd = addDays(now, 16); const totalQty = 260; @@ -198,7 +198,7 @@ export function getDemoData(): DashboardData { buildTraceItem(3, 55), ]; - // 当前订单 12 道工序横道图:工期 -10 ~ +16 天,每序约 2.17 天 + // 当前工单 12 道工序横道图:工期 -10 ~ +16 天,每序约 2.17 天 const stepDurationHours = ((planEnd.getTime() - planStart.getTime()) / 12) / 36e5; const progressSteps: DashboardData['progress']['steps'] = PROCESS_NAMES.map((name, i) => { const seqStart = new Date(planStart.getTime() + i * stepDurationHours * 36e5); @@ -295,7 +295,7 @@ export function getDemoData(): DashboardData { traceable: true, steps: progressSteps, }, - // 多订单轮播演示:首条与 progress 一致,另补两条在产订单 + // 多工单轮播演示:首条与 progress 一致,另补两条在产工单 progressList: [ { orderNo: 'WO-20260825-007', diff --git a/bj_power_dashboard/src/pages/LineModel.tsx b/bj_power_dashboard/src/pages/LineModel.tsx index 8ea1dc1..89f35bf 100644 --- a/bj_power_dashboard/src/pages/LineModel.tsx +++ b/bj_power_dashboard/src/pages/LineModel.tsx @@ -166,8 +166,12 @@ export function LineModel({ data }: { data: DashboardData }) { const mainMap = new Map(data.points.main.map((p) => [p.code, p])); const dockMap = new Map(data.points.dock.map((p) => [p.code, p])); const hasMain = (n: number) => mainMap.get(`C${n}`)?.has ?? false; - const hasDock = (g: number, r: 1 | 2) => dockMap.get(`G${g}${r === 1 ? 'L' : 'R'}`)?.has ?? false; const hasJbt = dockMap.get('JBT21')?.has ?? false; + // 左右互换(2026-11-03 拍板):偶数工位 地图左槽=GxR、右槽=GxL;奇数工位 地图左槽=GxL、右槽=GxR。 + // 占用与标签都按稳定码从后端数据取(label=中文,后端下发),不再写死。 + const dockCode = (g: number, slot: 1 | 2) => (g % 2 === 0 ? (slot === 1 ? `G${g}R` : `G${g}L`) : (slot === 1 ? `G${g}L` : `G${g}R`)); + const dockLabel = (g: number, slot: 1 | 2) => dockMap.get(dockCode(g, slot))?.label || (dockCode(g, slot) === `G${g}L` ? `工位${g}左` : `工位${g}右`); + const hasDockSlot = (g: number, slot: 1 | 2) => dockMap.get(dockCode(g, slot))?.has ?? false; const inStation = stations.filter((s) => !!s.currentSn).length; const inMain = data.points.main.filter((p) => p.has).length; @@ -290,10 +294,10 @@ export function LineModel({ data }: { data: DashboardData }) { {!isEnd && ( <> - - - - + + + + )} diff --git a/bj_power_dashboard/src/pages/ProductionBoard.tsx b/bj_power_dashboard/src/pages/ProductionBoard.tsx index 586e5f1..bead887 100644 --- a/bj_power_dashboard/src/pages/ProductionBoard.tsx +++ b/bj_power_dashboard/src/pages/ProductionBoard.tsx @@ -12,15 +12,15 @@ const C = { dim: '#64748b', }; -/** 同屏最多展示的订单数(多订单混生产:并列展示,不再轮播;超出部分折叠为 +N) */ +/** 同屏最多展示的工单数(多工单混生产:并列展示,不再轮播;超出部分折叠为 +N) */ const MAX_VISIBLE = 4; -/** 单张订单卡(单订单时占满左块):合同/工期/完成度 */ +/** 单张工单卡(单工单时占满左块):合同/工期/完成度 */ function OrderCard({ order }: { order: ProductionProgress }) { return (
- {order.contractNo || order.orderNo || '暂无在产订单'} + {order.contractNo || order.orderNo || '暂无在产工单'}
@@ -63,7 +63,7 @@ function OrderCard({ order }: { order: ProductionProgress }) { ); } -/** 紧凑订单行(多订单并列展示):一行一单,共享左块高度 */ +/** 紧凑工单行(多工单并列展示):一行一单,共享左块高度 */ function MiniOrderCard({ order }: { order: ProductionProgress }) { return (
(() => { const list = (data.progressList || []).filter((o) => o && (o.orderNo || o.contractNo)); if (list.length > 0) return list; @@ -158,14 +158,14 @@ export function ProductionBoard({ data }: { data: DashboardData }) { return (
- 当前订单 + 当前工单 {orders.length > 1 ? '多单并行 · 合同 · 工期 · 完成度' : '合同 · 工期 · 完成度'} {hiddenCount > 0 && ( +{hiddenCount} 单未展示 )}
- {/* 左:订单信息(多订单同屏并列,进行中排前;单订单保持原大卡) */} + {/* 左:工单信息(多工单同屏并列,进行中排前;单工单保持原大卡) */}
{visible.length === 1 && visible[0] ? ( diff --git a/bj_power_dashboard/src/services/dashboardService.ts b/bj_power_dashboard/src/services/dashboardService.ts index a54aef9..260119d 100644 --- a/bj_power_dashboard/src/services/dashboardService.ts +++ b/bj_power_dashboard/src/services/dashboardService.ts @@ -324,6 +324,11 @@ function normalize(raw: Partial): DashboardData { traceable: pr.traceable ?? false, steps: pr.steps ?? [], }, + // 多工单同屏:必须透传 progressList,否则前端永远回退单条 progress(历史 bug:多单只显示 1 个) + progressList: raw.progressList ?? [], + // R15(2026-11-03 拍板):虚拟工位滚动栏(地图右侧 14 号等)真实数据透传; + // 历史缺口:normalize 未映射该字段,SSE/轮询态下虚拟工位栏恒为空、仅演示态可见。 + virtualStations: raw.virtualStations ?? [], traces: raw.traces ?? [], trends: raw.trends ?? { production: [] }, points: { diff --git a/bj_power_dashboard/src/types.ts b/bj_power_dashboard/src/types.ts index 63b2110..321f5b4 100644 --- a/bj_power_dashboard/src/types.ts +++ b/bj_power_dashboard/src/types.ts @@ -3,7 +3,7 @@ * * 展示口径约定(甲方要求「体现好的东西」): * - 不直接展示合格率 / 不良数 / 报警等负面指标,改为正面表述(一次通过件数、全程受控、设备在线)。 - * - 展示重点是:当前订单(合同 · 负责人 · 工期 · 完成度 · 可追溯)、产能、质量保障能力。 + * - 展示重点是:当前工单(合同 · 负责人 · 工期 · 完成度 · 可追溯)、产能、质量保障能力。 * - 真实业务数据为空时由演示数据兜底,避免大屏出现 0 或空白(isDemo=true 时角落标注)。 */ @@ -42,7 +42,10 @@ export interface Station { /** 产线点位态(主线位置 / 接驳台) */ export interface LinePoint { + /** 稳定码:C1..C15 / G1L..G10R / JBT21(前端按码查占用) */ code: string; + /** 中文显示名(工位N左/右、库房接驳台),后端下发;缺省时前端回退 */ + label?: string; has: boolean; } @@ -142,7 +145,7 @@ export interface AlarmItem { } /** - * 当前订单(屏1 核心卡片) + * 当前工单(屏1 核心卡片) * 展示:合同信息、负责人、工期、完成度、可追溯。 */ export interface ProgressGanttStep { @@ -172,7 +175,7 @@ export interface ProductionProgress { /** 合同号(一合同 = 一工单) */ contractNo: string; productName: string; - /** 订单负责人 */ + /** 工单负责人 */ owner: string; /** 工期起 yyyy-MM-dd */ planStart: string; @@ -180,7 +183,7 @@ export interface ProductionProgress { planEnd: string; /** 距交期剩余天数(负数表示超期) */ remainDays: number; - /** 订单总量 */ + /** 工单总量 */ totalQty: number; /** 已完成量 */ doneQty: number; @@ -192,11 +195,11 @@ export interface ProductionProgress { processTotal: number; currentProcess: string; status: string; - /** 该订单已沉淀的工序追溯记录数(体现可追溯) */ + /** 该工单已沉淀的工序追溯记录数(体现可追溯) */ traceStepCount: number; /** 是否全程可追溯 */ traceable: boolean; - /** 当前订单 12 道工序横道图数据 */ + /** 当前工单 12 道工序横道图数据 */ steps: ProgressGanttStep[]; } @@ -250,7 +253,7 @@ export interface DashboardData { /** 虚拟工位(OFFLINE,不连PLC):产线动态地图"虚拟工位"滚动栏展示;后端未升级时为空 */ virtualStations?: Station[]; progress: ProductionProgress; - /** 当前在产订单列表(多订单轮播):进行中排前,最多 6 条,首条与 progress 一致;后端未升级时为空 */ + /** 当前在产工单列表(多工单轮播):进行中排前,最多 6 条,首条与 progress 一致;后端未升级时为空 */ progressList?: ProductionProgress[]; /** 追溯轮播数据(最近完工工件) */ traces: TraceItem[]; diff --git a/bj_power_mes/bj_power_mes.go b/bj_power_mes/bj_power_mes.go index 44ee010..27e1e05 100644 --- a/bj_power_mes/bj_power_mes.go +++ b/bj_power_mes/bj_power_mes.go @@ -346,6 +346,21 @@ func main() { } }() + // 退料 AGV 自动派车扫描(2026-11-04 口径定稿):每 10 秒一轮,拉取 WMS「PENDING+运输方式=AGV+未派车」 + // 退料单,传感器检测到退料接驳台有托盘且 JBT21 有空位才自动派车(JBT21 无空位等待,库管不点派车)。 + // PLC 托盘传感器为被动读取,物理上必须轮询才能"检测到";每轮仅查未派退料单,开销极小。 + go func() { + time.Sleep(15 * time.Second) + ticker := time.NewTicker(10 * time.Second) + defer ticker.Stop() + for range ticker.C { + bctx := context.Background() + if _, err := logic.New(ctx).AutoDispatchReturnAGV(bctx); err != nil { + gologx.Errorf("退料 AGV 自动派车扫描失败(WMS 不可达属正常): %v", err) + } + } + }() + fmt.Printf("Starting bj_power_mes server at %s:%d...\n", c.Host, c.Port) gologx.Infof("Starting bj_power_mes server at %s:%d...", c.Host, c.Port) diff --git a/bj_power_mes/ent/agvvehiclestate.go b/bj_power_mes/ent/agvvehiclestate.go new file mode 100644 index 0000000..2bae2b2 --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate.go @@ -0,0 +1,160 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "bj_power_mes/ent/agvvehiclestate" + "fmt" + "strings" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" +) + +// AgvVehicleState AGV 载货状态台账:按 agv_code 逐台记录有托盘/空车,取货/卸货确认与人工维护写入,派车防撞校验消费。 +type AgvVehicleState struct { + config `json:"-"` + // ID of the ent. + ID int `json:"id,omitempty"` + // 车辆编号(RCS robotCode/agvCode;RCS 未分车时=DEFAULT 未知车辆) + AgvCode string `json:"agv_code,omitempty"` + // 载货状态:true=有托盘(载货) false=空车 + HasPallet bool `json:"has_pallet,omitempty"` + // 状态来源:AUTO_LOAD取货确认/AUTO_UNLOAD卸货确认/MANUAL人工维护 + Source string `json:"source,omitempty"` + // 最近更新人 + UpdatedBy string `json:"updated_by,omitempty"` + // 最近更新时间 unix秒 + UpdatedAt int64 `json:"updated_at,omitempty"` + // 备注(人工修改原因等) + Remark string `json:"remark,omitempty"` + selectValues sql.SelectValues +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*AgvVehicleState) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case agvvehiclestate.FieldHasPallet: + values[i] = new(sql.NullBool) + case agvvehiclestate.FieldID, agvvehiclestate.FieldUpdatedAt: + values[i] = new(sql.NullInt64) + case agvvehiclestate.FieldAgvCode, agvvehiclestate.FieldSource, agvvehiclestate.FieldUpdatedBy, agvvehiclestate.FieldRemark: + values[i] = new(sql.NullString) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the AgvVehicleState fields. +func (_m *AgvVehicleState) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case agvvehiclestate.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + _m.ID = int(value.Int64) + case agvvehiclestate.FieldAgvCode: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field agv_code", values[i]) + } else if value.Valid { + _m.AgvCode = value.String + } + case agvvehiclestate.FieldHasPallet: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field has_pallet", values[i]) + } else if value.Valid { + _m.HasPallet = value.Bool + } + case agvvehiclestate.FieldSource: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field source", values[i]) + } else if value.Valid { + _m.Source = value.String + } + case agvvehiclestate.FieldUpdatedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field updated_by", values[i]) + } else if value.Valid { + _m.UpdatedBy = value.String + } + case agvvehiclestate.FieldUpdatedAt: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field updated_at", values[i]) + } else if value.Valid { + _m.UpdatedAt = value.Int64 + } + case agvvehiclestate.FieldRemark: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field remark", values[i]) + } else if value.Valid { + _m.Remark = value.String + } + default: + _m.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the AgvVehicleState. +// This includes values selected through modifiers, order, etc. +func (_m *AgvVehicleState) Value(name string) (ent.Value, error) { + return _m.selectValues.Get(name) +} + +// Update returns a builder for updating this AgvVehicleState. +// Note that you need to call AgvVehicleState.Unwrap() before calling this method if this AgvVehicleState +// was returned from a transaction, and the transaction was committed or rolled back. +func (_m *AgvVehicleState) Update() *AgvVehicleStateUpdateOne { + return NewAgvVehicleStateClient(_m.config).UpdateOne(_m) +} + +// Unwrap unwraps the AgvVehicleState entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (_m *AgvVehicleState) Unwrap() *AgvVehicleState { + _tx, ok := _m.config.driver.(*txDriver) + if !ok { + panic("ent: AgvVehicleState is not a transactional entity") + } + _m.config.driver = _tx.drv + return _m +} + +// String implements the fmt.Stringer. +func (_m *AgvVehicleState) String() string { + var builder strings.Builder + builder.WriteString("AgvVehicleState(") + builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID)) + builder.WriteString("agv_code=") + builder.WriteString(_m.AgvCode) + builder.WriteString(", ") + builder.WriteString("has_pallet=") + builder.WriteString(fmt.Sprintf("%v", _m.HasPallet)) + builder.WriteString(", ") + builder.WriteString("source=") + builder.WriteString(_m.Source) + builder.WriteString(", ") + builder.WriteString("updated_by=") + builder.WriteString(_m.UpdatedBy) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(fmt.Sprintf("%v", _m.UpdatedAt)) + builder.WriteString(", ") + builder.WriteString("remark=") + builder.WriteString(_m.Remark) + builder.WriteByte(')') + return builder.String() +} + +// AgvVehicleStates is a parsable slice of AgvVehicleState. +type AgvVehicleStates []*AgvVehicleState diff --git a/bj_power_mes/ent/agvvehiclestate/agvvehiclestate.go b/bj_power_mes/ent/agvvehiclestate/agvvehiclestate.go new file mode 100644 index 0000000..07c5b8d --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate/agvvehiclestate.go @@ -0,0 +1,108 @@ +// Code generated by ent, DO NOT EDIT. + +package agvvehiclestate + +import ( + "entgo.io/ent/dialect/sql" +) + +const ( + // Label holds the string label denoting the agvvehiclestate type in the database. + Label = "agv_vehicle_state" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldAgvCode holds the string denoting the agv_code field in the database. + FieldAgvCode = "agv_code" + // FieldHasPallet holds the string denoting the has_pallet field in the database. + FieldHasPallet = "has_pallet" + // FieldSource holds the string denoting the source field in the database. + FieldSource = "source" + // FieldUpdatedBy holds the string denoting the updated_by field in the database. + FieldUpdatedBy = "updated_by" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldRemark holds the string denoting the remark field in the database. + FieldRemark = "remark" + // Table holds the table name of the agvvehiclestate in the database. + Table = "agv_vehicle_state" +) + +// Columns holds all SQL columns for agvvehiclestate fields. +var Columns = []string{ + FieldID, + FieldAgvCode, + FieldHasPallet, + FieldSource, + FieldUpdatedBy, + FieldUpdatedAt, + FieldRemark, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +var ( + // AgvCodeValidator is a validator for the "agv_code" field. It is called by the builders before save. + AgvCodeValidator func(string) error + // DefaultHasPallet holds the default value on creation for the "has_pallet" field. + DefaultHasPallet bool + // DefaultSource holds the default value on creation for the "source" field. + DefaultSource string + // SourceValidator is a validator for the "source" field. It is called by the builders before save. + SourceValidator func(string) error + // DefaultUpdatedBy holds the default value on creation for the "updated_by" field. + DefaultUpdatedBy string + // UpdatedByValidator is a validator for the "updated_by" field. It is called by the builders before save. + UpdatedByValidator func(string) error + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt int64 + // DefaultRemark holds the default value on creation for the "remark" field. + DefaultRemark string + // RemarkValidator is a validator for the "remark" field. It is called by the builders before save. + RemarkValidator func(string) error +) + +// OrderOption defines the ordering options for the AgvVehicleState queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByAgvCode orders the results by the agv_code field. +func ByAgvCode(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldAgvCode, opts...).ToFunc() +} + +// ByHasPallet orders the results by the has_pallet field. +func ByHasPallet(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldHasPallet, opts...).ToFunc() +} + +// BySource orders the results by the source field. +func BySource(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldSource, opts...).ToFunc() +} + +// ByUpdatedBy orders the results by the updated_by field. +func ByUpdatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedBy, opts...).ToFunc() +} + +// ByUpdatedAt orders the results by the updated_at field. +func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc() +} + +// ByRemark orders the results by the remark field. +func ByRemark(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldRemark, opts...).ToFunc() +} diff --git a/bj_power_mes/ent/agvvehiclestate/where.go b/bj_power_mes/ent/agvvehiclestate/where.go new file mode 100644 index 0000000..bc9acbf --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate/where.go @@ -0,0 +1,409 @@ +// Code generated by ent, DO NOT EDIT. + +package agvvehiclestate + +import ( + "bj_power_mes/ent/predicate" + + "entgo.io/ent/dialect/sql" +) + +// ID filters vertices based on their ID field. +func ID(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldID, id)) +} + +// AgvCode applies equality check predicate on the "agv_code" field. It's identical to AgvCodeEQ. +func AgvCode(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldAgvCode, v)) +} + +// HasPallet applies equality check predicate on the "has_pallet" field. It's identical to HasPalletEQ. +func HasPallet(v bool) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldHasPallet, v)) +} + +// Source applies equality check predicate on the "source" field. It's identical to SourceEQ. +func Source(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldSource, v)) +} + +// UpdatedBy applies equality check predicate on the "updated_by" field. It's identical to UpdatedByEQ. +func UpdatedBy(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ. +func Remark(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldRemark, v)) +} + +// AgvCodeEQ applies the EQ predicate on the "agv_code" field. +func AgvCodeEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldAgvCode, v)) +} + +// AgvCodeNEQ applies the NEQ predicate on the "agv_code" field. +func AgvCodeNEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldAgvCode, v)) +} + +// AgvCodeIn applies the In predicate on the "agv_code" field. +func AgvCodeIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldAgvCode, vs...)) +} + +// AgvCodeNotIn applies the NotIn predicate on the "agv_code" field. +func AgvCodeNotIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldAgvCode, vs...)) +} + +// AgvCodeGT applies the GT predicate on the "agv_code" field. +func AgvCodeGT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldAgvCode, v)) +} + +// AgvCodeGTE applies the GTE predicate on the "agv_code" field. +func AgvCodeGTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldAgvCode, v)) +} + +// AgvCodeLT applies the LT predicate on the "agv_code" field. +func AgvCodeLT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldAgvCode, v)) +} + +// AgvCodeLTE applies the LTE predicate on the "agv_code" field. +func AgvCodeLTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldAgvCode, v)) +} + +// AgvCodeContains applies the Contains predicate on the "agv_code" field. +func AgvCodeContains(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContains(FieldAgvCode, v)) +} + +// AgvCodeHasPrefix applies the HasPrefix predicate on the "agv_code" field. +func AgvCodeHasPrefix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasPrefix(FieldAgvCode, v)) +} + +// AgvCodeHasSuffix applies the HasSuffix predicate on the "agv_code" field. +func AgvCodeHasSuffix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasSuffix(FieldAgvCode, v)) +} + +// AgvCodeEqualFold applies the EqualFold predicate on the "agv_code" field. +func AgvCodeEqualFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEqualFold(FieldAgvCode, v)) +} + +// AgvCodeContainsFold applies the ContainsFold predicate on the "agv_code" field. +func AgvCodeContainsFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContainsFold(FieldAgvCode, v)) +} + +// HasPalletEQ applies the EQ predicate on the "has_pallet" field. +func HasPalletEQ(v bool) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldHasPallet, v)) +} + +// HasPalletNEQ applies the NEQ predicate on the "has_pallet" field. +func HasPalletNEQ(v bool) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldHasPallet, v)) +} + +// SourceEQ applies the EQ predicate on the "source" field. +func SourceEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldSource, v)) +} + +// SourceNEQ applies the NEQ predicate on the "source" field. +func SourceNEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldSource, v)) +} + +// SourceIn applies the In predicate on the "source" field. +func SourceIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldSource, vs...)) +} + +// SourceNotIn applies the NotIn predicate on the "source" field. +func SourceNotIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldSource, vs...)) +} + +// SourceGT applies the GT predicate on the "source" field. +func SourceGT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldSource, v)) +} + +// SourceGTE applies the GTE predicate on the "source" field. +func SourceGTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldSource, v)) +} + +// SourceLT applies the LT predicate on the "source" field. +func SourceLT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldSource, v)) +} + +// SourceLTE applies the LTE predicate on the "source" field. +func SourceLTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldSource, v)) +} + +// SourceContains applies the Contains predicate on the "source" field. +func SourceContains(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContains(FieldSource, v)) +} + +// SourceHasPrefix applies the HasPrefix predicate on the "source" field. +func SourceHasPrefix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasPrefix(FieldSource, v)) +} + +// SourceHasSuffix applies the HasSuffix predicate on the "source" field. +func SourceHasSuffix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasSuffix(FieldSource, v)) +} + +// SourceEqualFold applies the EqualFold predicate on the "source" field. +func SourceEqualFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEqualFold(FieldSource, v)) +} + +// SourceContainsFold applies the ContainsFold predicate on the "source" field. +func SourceContainsFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContainsFold(FieldSource, v)) +} + +// UpdatedByEQ applies the EQ predicate on the "updated_by" field. +func UpdatedByEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// UpdatedByNEQ applies the NEQ predicate on the "updated_by" field. +func UpdatedByNEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldUpdatedBy, v)) +} + +// UpdatedByIn applies the In predicate on the "updated_by" field. +func UpdatedByIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByNotIn applies the NotIn predicate on the "updated_by" field. +func UpdatedByNotIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByGT applies the GT predicate on the "updated_by" field. +func UpdatedByGT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldUpdatedBy, v)) +} + +// UpdatedByGTE applies the GTE predicate on the "updated_by" field. +func UpdatedByGTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldUpdatedBy, v)) +} + +// UpdatedByLT applies the LT predicate on the "updated_by" field. +func UpdatedByLT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldUpdatedBy, v)) +} + +// UpdatedByLTE applies the LTE predicate on the "updated_by" field. +func UpdatedByLTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldUpdatedBy, v)) +} + +// UpdatedByContains applies the Contains predicate on the "updated_by" field. +func UpdatedByContains(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContains(FieldUpdatedBy, v)) +} + +// UpdatedByHasPrefix applies the HasPrefix predicate on the "updated_by" field. +func UpdatedByHasPrefix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasPrefix(FieldUpdatedBy, v)) +} + +// UpdatedByHasSuffix applies the HasSuffix predicate on the "updated_by" field. +func UpdatedByHasSuffix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasSuffix(FieldUpdatedBy, v)) +} + +// UpdatedByEqualFold applies the EqualFold predicate on the "updated_by" field. +func UpdatedByEqualFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEqualFold(FieldUpdatedBy, v)) +} + +// UpdatedByContainsFold applies the ContainsFold predicate on the "updated_by" field. +func UpdatedByContainsFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContainsFold(FieldUpdatedBy, v)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v int64) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// RemarkEQ applies the EQ predicate on the "remark" field. +func RemarkEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEQ(FieldRemark, v)) +} + +// RemarkNEQ applies the NEQ predicate on the "remark" field. +func RemarkNEQ(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNEQ(FieldRemark, v)) +} + +// RemarkIn applies the In predicate on the "remark" field. +func RemarkIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldIn(FieldRemark, vs...)) +} + +// RemarkNotIn applies the NotIn predicate on the "remark" field. +func RemarkNotIn(vs ...string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldNotIn(FieldRemark, vs...)) +} + +// RemarkGT applies the GT predicate on the "remark" field. +func RemarkGT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGT(FieldRemark, v)) +} + +// RemarkGTE applies the GTE predicate on the "remark" field. +func RemarkGTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldGTE(FieldRemark, v)) +} + +// RemarkLT applies the LT predicate on the "remark" field. +func RemarkLT(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLT(FieldRemark, v)) +} + +// RemarkLTE applies the LTE predicate on the "remark" field. +func RemarkLTE(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldLTE(FieldRemark, v)) +} + +// RemarkContains applies the Contains predicate on the "remark" field. +func RemarkContains(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContains(FieldRemark, v)) +} + +// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field. +func RemarkHasPrefix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasPrefix(FieldRemark, v)) +} + +// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field. +func RemarkHasSuffix(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldHasSuffix(FieldRemark, v)) +} + +// RemarkEqualFold applies the EqualFold predicate on the "remark" field. +func RemarkEqualFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldEqualFold(FieldRemark, v)) +} + +// RemarkContainsFold applies the ContainsFold predicate on the "remark" field. +func RemarkContainsFold(v string) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.FieldContainsFold(FieldRemark, v)) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.AgvVehicleState) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.AgvVehicleState) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.AgvVehicleState) predicate.AgvVehicleState { + return predicate.AgvVehicleState(sql.NotPredicates(p)) +} diff --git a/bj_power_mes/ent/agvvehiclestate_create.go b/bj_power_mes/ent/agvvehiclestate_create.go new file mode 100644 index 0000000..faab557 --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate_create.go @@ -0,0 +1,334 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "bj_power_mes/ent/agvvehiclestate" + "context" + "errors" + "fmt" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// AgvVehicleStateCreate is the builder for creating a AgvVehicleState entity. +type AgvVehicleStateCreate struct { + config + mutation *AgvVehicleStateMutation + hooks []Hook +} + +// SetAgvCode sets the "agv_code" field. +func (_c *AgvVehicleStateCreate) SetAgvCode(v string) *AgvVehicleStateCreate { + _c.mutation.SetAgvCode(v) + return _c +} + +// SetHasPallet sets the "has_pallet" field. +func (_c *AgvVehicleStateCreate) SetHasPallet(v bool) *AgvVehicleStateCreate { + _c.mutation.SetHasPallet(v) + return _c +} + +// SetNillableHasPallet sets the "has_pallet" field if the given value is not nil. +func (_c *AgvVehicleStateCreate) SetNillableHasPallet(v *bool) *AgvVehicleStateCreate { + if v != nil { + _c.SetHasPallet(*v) + } + return _c +} + +// SetSource sets the "source" field. +func (_c *AgvVehicleStateCreate) SetSource(v string) *AgvVehicleStateCreate { + _c.mutation.SetSource(v) + return _c +} + +// SetNillableSource sets the "source" field if the given value is not nil. +func (_c *AgvVehicleStateCreate) SetNillableSource(v *string) *AgvVehicleStateCreate { + if v != nil { + _c.SetSource(*v) + } + return _c +} + +// SetUpdatedBy sets the "updated_by" field. +func (_c *AgvVehicleStateCreate) SetUpdatedBy(v string) *AgvVehicleStateCreate { + _c.mutation.SetUpdatedBy(v) + return _c +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_c *AgvVehicleStateCreate) SetNillableUpdatedBy(v *string) *AgvVehicleStateCreate { + if v != nil { + _c.SetUpdatedBy(*v) + } + return _c +} + +// SetUpdatedAt sets the "updated_at" field. +func (_c *AgvVehicleStateCreate) SetUpdatedAt(v int64) *AgvVehicleStateCreate { + _c.mutation.SetUpdatedAt(v) + return _c +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (_c *AgvVehicleStateCreate) SetNillableUpdatedAt(v *int64) *AgvVehicleStateCreate { + if v != nil { + _c.SetUpdatedAt(*v) + } + return _c +} + +// SetRemark sets the "remark" field. +func (_c *AgvVehicleStateCreate) SetRemark(v string) *AgvVehicleStateCreate { + _c.mutation.SetRemark(v) + return _c +} + +// SetNillableRemark sets the "remark" field if the given value is not nil. +func (_c *AgvVehicleStateCreate) SetNillableRemark(v *string) *AgvVehicleStateCreate { + if v != nil { + _c.SetRemark(*v) + } + return _c +} + +// Mutation returns the AgvVehicleStateMutation object of the builder. +func (_c *AgvVehicleStateCreate) Mutation() *AgvVehicleStateMutation { + return _c.mutation +} + +// Save creates the AgvVehicleState in the database. +func (_c *AgvVehicleStateCreate) Save(ctx context.Context) (*AgvVehicleState, error) { + _c.defaults() + return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (_c *AgvVehicleStateCreate) SaveX(ctx context.Context) *AgvVehicleState { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AgvVehicleStateCreate) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AgvVehicleStateCreate) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (_c *AgvVehicleStateCreate) defaults() { + if _, ok := _c.mutation.HasPallet(); !ok { + v := agvvehiclestate.DefaultHasPallet + _c.mutation.SetHasPallet(v) + } + if _, ok := _c.mutation.Source(); !ok { + v := agvvehiclestate.DefaultSource + _c.mutation.SetSource(v) + } + if _, ok := _c.mutation.UpdatedBy(); !ok { + v := agvvehiclestate.DefaultUpdatedBy + _c.mutation.SetUpdatedBy(v) + } + if _, ok := _c.mutation.UpdatedAt(); !ok { + v := agvvehiclestate.DefaultUpdatedAt + _c.mutation.SetUpdatedAt(v) + } + if _, ok := _c.mutation.Remark(); !ok { + v := agvvehiclestate.DefaultRemark + _c.mutation.SetRemark(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_c *AgvVehicleStateCreate) check() error { + if _, ok := _c.mutation.AgvCode(); !ok { + return &ValidationError{Name: "agv_code", err: errors.New(`ent: missing required field "AgvVehicleState.agv_code"`)} + } + if v, ok := _c.mutation.AgvCode(); ok { + if err := agvvehiclestate.AgvCodeValidator(v); err != nil { + return &ValidationError{Name: "agv_code", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.agv_code": %w`, err)} + } + } + if _, ok := _c.mutation.HasPallet(); !ok { + return &ValidationError{Name: "has_pallet", err: errors.New(`ent: missing required field "AgvVehicleState.has_pallet"`)} + } + if _, ok := _c.mutation.Source(); !ok { + return &ValidationError{Name: "source", err: errors.New(`ent: missing required field "AgvVehicleState.source"`)} + } + if v, ok := _c.mutation.Source(); ok { + if err := agvvehiclestate.SourceValidator(v); err != nil { + return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.source": %w`, err)} + } + } + if _, ok := _c.mutation.UpdatedBy(); !ok { + return &ValidationError{Name: "updated_by", err: errors.New(`ent: missing required field "AgvVehicleState.updated_by"`)} + } + if v, ok := _c.mutation.UpdatedBy(); ok { + if err := agvvehiclestate.UpdatedByValidator(v); err != nil { + return &ValidationError{Name: "updated_by", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.updated_by": %w`, err)} + } + } + if _, ok := _c.mutation.UpdatedAt(); !ok { + return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "AgvVehicleState.updated_at"`)} + } + if _, ok := _c.mutation.Remark(); !ok { + return &ValidationError{Name: "remark", err: errors.New(`ent: missing required field "AgvVehicleState.remark"`)} + } + if v, ok := _c.mutation.Remark(); ok { + if err := agvvehiclestate.RemarkValidator(v); err != nil { + return &ValidationError{Name: "remark", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.remark": %w`, err)} + } + } + return nil +} + +func (_c *AgvVehicleStateCreate) sqlSave(ctx context.Context) (*AgvVehicleState, error) { + if err := _c.check(); err != nil { + return nil, err + } + _node, _spec := _c.createSpec() + if err := sqlgraph.CreateNode(ctx, _c.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + id := _spec.ID.Value.(int64) + _node.ID = int(id) + _c.mutation.id = &_node.ID + _c.mutation.done = true + return _node, nil +} + +func (_c *AgvVehicleStateCreate) createSpec() (*AgvVehicleState, *sqlgraph.CreateSpec) { + var ( + _node = &AgvVehicleState{config: _c.config} + _spec = sqlgraph.NewCreateSpec(agvvehiclestate.Table, sqlgraph.NewFieldSpec(agvvehiclestate.FieldID, field.TypeInt)) + ) + if value, ok := _c.mutation.AgvCode(); ok { + _spec.SetField(agvvehiclestate.FieldAgvCode, field.TypeString, value) + _node.AgvCode = value + } + if value, ok := _c.mutation.HasPallet(); ok { + _spec.SetField(agvvehiclestate.FieldHasPallet, field.TypeBool, value) + _node.HasPallet = value + } + if value, ok := _c.mutation.Source(); ok { + _spec.SetField(agvvehiclestate.FieldSource, field.TypeString, value) + _node.Source = value + } + if value, ok := _c.mutation.UpdatedBy(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedBy, field.TypeString, value) + _node.UpdatedBy = value + } + if value, ok := _c.mutation.UpdatedAt(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedAt, field.TypeInt64, value) + _node.UpdatedAt = value + } + if value, ok := _c.mutation.Remark(); ok { + _spec.SetField(agvvehiclestate.FieldRemark, field.TypeString, value) + _node.Remark = value + } + return _node, _spec +} + +// AgvVehicleStateCreateBulk is the builder for creating many AgvVehicleState entities in bulk. +type AgvVehicleStateCreateBulk struct { + config + err error + builders []*AgvVehicleStateCreate +} + +// Save creates the AgvVehicleState entities in the database. +func (_c *AgvVehicleStateCreateBulk) Save(ctx context.Context) ([]*AgvVehicleState, error) { + if _c.err != nil { + return nil, _c.err + } + specs := make([]*sqlgraph.CreateSpec, len(_c.builders)) + nodes := make([]*AgvVehicleState, len(_c.builders)) + mutators := make([]Mutator, len(_c.builders)) + for i := range _c.builders { + func(i int, root context.Context) { + builder := _c.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*AgvVehicleStateMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, _c.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + if specs[i].ID.Value != nil { + id := specs[i].ID.Value.(int64) + nodes[i].ID = int(id) + } + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, _c.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (_c *AgvVehicleStateCreateBulk) SaveX(ctx context.Context) []*AgvVehicleState { + v, err := _c.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (_c *AgvVehicleStateCreateBulk) Exec(ctx context.Context) error { + _, err := _c.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_c *AgvVehicleStateCreateBulk) ExecX(ctx context.Context) { + if err := _c.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/bj_power_mes/ent/agvvehiclestate_delete.go b/bj_power_mes/ent/agvvehiclestate_delete.go new file mode 100644 index 0000000..b99364e --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "bj_power_mes/ent/agvvehiclestate" + "bj_power_mes/ent/predicate" + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// AgvVehicleStateDelete is the builder for deleting a AgvVehicleState entity. +type AgvVehicleStateDelete struct { + config + hooks []Hook + mutation *AgvVehicleStateMutation +} + +// Where appends a list predicates to the AgvVehicleStateDelete builder. +func (_d *AgvVehicleStateDelete) Where(ps ...predicate.AgvVehicleState) *AgvVehicleStateDelete { + _d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (_d *AgvVehicleStateDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AgvVehicleStateDelete) ExecX(ctx context.Context) int { + n, err := _d.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (_d *AgvVehicleStateDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(agvvehiclestate.Table, sqlgraph.NewFieldSpec(agvvehiclestate.FieldID, field.TypeInt)) + if ps := _d.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + _d.mutation.done = true + return affected, err +} + +// AgvVehicleStateDeleteOne is the builder for deleting a single AgvVehicleState entity. +type AgvVehicleStateDeleteOne struct { + _d *AgvVehicleStateDelete +} + +// Where appends a list predicates to the AgvVehicleStateDelete builder. +func (_d *AgvVehicleStateDeleteOne) Where(ps ...predicate.AgvVehicleState) *AgvVehicleStateDeleteOne { + _d._d.mutation.Where(ps...) + return _d +} + +// Exec executes the deletion query. +func (_d *AgvVehicleStateDeleteOne) Exec(ctx context.Context) error { + n, err := _d._d.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{agvvehiclestate.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (_d *AgvVehicleStateDeleteOne) ExecX(ctx context.Context) { + if err := _d.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/bj_power_mes/ent/agvvehiclestate_query.go b/bj_power_mes/ent/agvvehiclestate_query.go new file mode 100644 index 0000000..a5cb5d3 --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate_query.go @@ -0,0 +1,577 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "bj_power_mes/ent/agvvehiclestate" + "bj_power_mes/ent/predicate" + "context" + "fmt" + "math" + + "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// AgvVehicleStateQuery is the builder for querying AgvVehicleState entities. +type AgvVehicleStateQuery struct { + config + ctx *QueryContext + order []agvvehiclestate.OrderOption + inters []Interceptor + predicates []predicate.AgvVehicleState + modifiers []func(*sql.Selector) + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the AgvVehicleStateQuery builder. +func (_q *AgvVehicleStateQuery) Where(ps ...predicate.AgvVehicleState) *AgvVehicleStateQuery { + _q.predicates = append(_q.predicates, ps...) + return _q +} + +// Limit the number of records to be returned by this query. +func (_q *AgvVehicleStateQuery) Limit(limit int) *AgvVehicleStateQuery { + _q.ctx.Limit = &limit + return _q +} + +// Offset to start from. +func (_q *AgvVehicleStateQuery) Offset(offset int) *AgvVehicleStateQuery { + _q.ctx.Offset = &offset + return _q +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (_q *AgvVehicleStateQuery) Unique(unique bool) *AgvVehicleStateQuery { + _q.ctx.Unique = &unique + return _q +} + +// Order specifies how the records should be ordered. +func (_q *AgvVehicleStateQuery) Order(o ...agvvehiclestate.OrderOption) *AgvVehicleStateQuery { + _q.order = append(_q.order, o...) + return _q +} + +// First returns the first AgvVehicleState entity from the query. +// Returns a *NotFoundError when no AgvVehicleState was found. +func (_q *AgvVehicleStateQuery) First(ctx context.Context) (*AgvVehicleState, error) { + nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst)) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{agvvehiclestate.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) FirstX(ctx context.Context) *AgvVehicleState { + node, err := _q.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first AgvVehicleState ID from the query. +// Returns a *NotFoundError when no AgvVehicleState ID was found. +func (_q *AgvVehicleStateQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{agvvehiclestate.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) FirstIDX(ctx context.Context) int { + id, err := _q.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single AgvVehicleState entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one AgvVehicleState entity is found. +// Returns a *NotFoundError when no AgvVehicleState entities are found. +func (_q *AgvVehicleStateQuery) Only(ctx context.Context) (*AgvVehicleState, error) { + nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly)) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{agvvehiclestate.Label} + default: + return nil, &NotSingularError{agvvehiclestate.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) OnlyX(ctx context.Context) *AgvVehicleState { + node, err := _q.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only AgvVehicleState ID in the query. +// Returns a *NotSingularError when more than one AgvVehicleState ID is found. +// Returns a *NotFoundError when no entities are found. +func (_q *AgvVehicleStateQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{agvvehiclestate.Label} + default: + err = &NotSingularError{agvvehiclestate.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) OnlyIDX(ctx context.Context) int { + id, err := _q.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of AgvVehicleStates. +func (_q *AgvVehicleStateQuery) All(ctx context.Context) ([]*AgvVehicleState, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll) + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*AgvVehicleState, *AgvVehicleStateQuery]() + return withInterceptors[[]*AgvVehicleState](ctx, _q, qr, _q.inters) +} + +// AllX is like All, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) AllX(ctx context.Context) []*AgvVehicleState { + nodes, err := _q.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of AgvVehicleState IDs. +func (_q *AgvVehicleStateQuery) IDs(ctx context.Context) (ids []int, err error) { + if _q.ctx.Unique == nil && _q.path != nil { + _q.Unique(true) + } + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs) + if err = _q.Select(agvvehiclestate.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) IDsX(ctx context.Context) []int { + ids, err := _q.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (_q *AgvVehicleStateQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount) + if err := _q.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, _q, querierCount[*AgvVehicleStateQuery](), _q.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) CountX(ctx context.Context) int { + count, err := _q.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (_q *AgvVehicleStateQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist) + switch _, err := _q.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (_q *AgvVehicleStateQuery) ExistX(ctx context.Context) bool { + exist, err := _q.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the AgvVehicleStateQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (_q *AgvVehicleStateQuery) Clone() *AgvVehicleStateQuery { + if _q == nil { + return nil + } + return &AgvVehicleStateQuery{ + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]agvvehiclestate.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.AgvVehicleState{}, _q.predicates...), + // clone intermediate query. + sql: _q.sql.Clone(), + path: _q.path, + modifiers: append([]func(*sql.Selector){}, _q.modifiers...), + } +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// AgvCode string `json:"agv_code,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.AgvVehicleState.Query(). +// GroupBy(agvvehiclestate.FieldAgvCode). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (_q *AgvVehicleStateQuery) GroupBy(field string, fields ...string) *AgvVehicleStateGroupBy { + _q.ctx.Fields = append([]string{field}, fields...) + grbuild := &AgvVehicleStateGroupBy{build: _q} + grbuild.flds = &_q.ctx.Fields + grbuild.label = agvvehiclestate.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// AgvCode string `json:"agv_code,omitempty"` +// } +// +// client.AgvVehicleState.Query(). +// Select(agvvehiclestate.FieldAgvCode). +// Scan(ctx, &v) +func (_q *AgvVehicleStateQuery) Select(fields ...string) *AgvVehicleStateSelect { + _q.ctx.Fields = append(_q.ctx.Fields, fields...) + sbuild := &AgvVehicleStateSelect{AgvVehicleStateQuery: _q} + sbuild.label = agvvehiclestate.Label + sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a AgvVehicleStateSelect configured with the given aggregations. +func (_q *AgvVehicleStateQuery) Aggregate(fns ...AggregateFunc) *AgvVehicleStateSelect { + return _q.Select().Aggregate(fns...) +} + +func (_q *AgvVehicleStateQuery) prepareQuery(ctx context.Context) error { + for _, inter := range _q.inters { + if inter == nil { + return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, _q); err != nil { + return err + } + } + } + for _, f := range _q.ctx.Fields { + if !agvvehiclestate.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if _q.path != nil { + prev, err := _q.path(ctx) + if err != nil { + return err + } + _q.sql = prev + } + return nil +} + +func (_q *AgvVehicleStateQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*AgvVehicleState, error) { + var ( + nodes = []*AgvVehicleState{} + _spec = _q.querySpec() + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*AgvVehicleState).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &AgvVehicleState{config: _q.config} + nodes = append(nodes, node) + return node.assignValues(columns, values) + } + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + return nodes, nil +} + +func (_q *AgvVehicleStateQuery) sqlCount(ctx context.Context) (int, error) { + _spec := _q.querySpec() + if len(_q.modifiers) > 0 { + _spec.Modifiers = _q.modifiers + } + _spec.Node.Columns = _q.ctx.Fields + if len(_q.ctx.Fields) > 0 { + _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique + } + return sqlgraph.CountNodes(ctx, _q.driver, _spec) +} + +func (_q *AgvVehicleStateQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(agvvehiclestate.Table, agvvehiclestate.Columns, sqlgraph.NewFieldSpec(agvvehiclestate.FieldID, field.TypeInt)) + _spec.From = _q.sql + if unique := _q.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if _q.path != nil { + _spec.Unique = true + } + if fields := _q.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, agvvehiclestate.FieldID) + for i := range fields { + if fields[i] != agvvehiclestate.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := _q.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := _q.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := _q.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := _q.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (_q *AgvVehicleStateQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(_q.driver.Dialect()) + t1 := builder.Table(agvvehiclestate.Table) + columns := _q.ctx.Fields + if len(columns) == 0 { + columns = agvvehiclestate.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if _q.sql != nil { + selector = _q.sql + selector.Select(selector.Columns(columns...)...) + } + if _q.ctx.Unique != nil && *_q.ctx.Unique { + selector.Distinct() + } + for _, m := range _q.modifiers { + m(selector) + } + for _, p := range _q.predicates { + p(selector) + } + for _, p := range _q.order { + p(selector) + } + if offset := _q.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := _q.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// ForUpdate locks the selected rows against concurrent updates, and prevent them from being +// updated, deleted or "selected ... for update" by other sessions, until the transaction is +// either committed or rolled-back. +func (_q *AgvVehicleStateQuery) ForUpdate(opts ...sql.LockOption) *AgvVehicleStateQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForUpdate(opts...) + }) + return _q +} + +// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock +// on any rows that are read. Other sessions can read the rows, but cannot modify them +// until your transaction commits. +func (_q *AgvVehicleStateQuery) ForShare(opts ...sql.LockOption) *AgvVehicleStateQuery { + if _q.driver.Dialect() == dialect.Postgres { + _q.Unique(false) + } + _q.modifiers = append(_q.modifiers, func(s *sql.Selector) { + s.ForShare(opts...) + }) + return _q +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (_q *AgvVehicleStateQuery) Modify(modifiers ...func(s *sql.Selector)) *AgvVehicleStateSelect { + _q.modifiers = append(_q.modifiers, modifiers...) + return _q.Select() +} + +// AgvVehicleStateGroupBy is the group-by builder for AgvVehicleState entities. +type AgvVehicleStateGroupBy struct { + selector + build *AgvVehicleStateQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (_g *AgvVehicleStateGroupBy) Aggregate(fns ...AggregateFunc) *AgvVehicleStateGroupBy { + _g.fns = append(_g.fns, fns...) + return _g +} + +// Scan applies the selector query and scans the result into the given value. +func (_g *AgvVehicleStateGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy) + if err := _g.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AgvVehicleStateQuery, *AgvVehicleStateGroupBy](ctx, _g.build, _g, _g.build.inters, v) +} + +func (_g *AgvVehicleStateGroupBy) sqlScan(ctx context.Context, root *AgvVehicleStateQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(_g.fns)) + for _, fn := range _g.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*_g.flds)+len(_g.fns)) + for _, f := range *_g.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*_g.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _g.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// AgvVehicleStateSelect is the builder for selecting fields of AgvVehicleState entities. +type AgvVehicleStateSelect struct { + *AgvVehicleStateQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (_s *AgvVehicleStateSelect) Aggregate(fns ...AggregateFunc) *AgvVehicleStateSelect { + _s.fns = append(_s.fns, fns...) + return _s +} + +// Scan applies the selector query and scans the result into the given value. +func (_s *AgvVehicleStateSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect) + if err := _s.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*AgvVehicleStateQuery, *AgvVehicleStateSelect](ctx, _s.AgvVehicleStateQuery, _s, _s.inters, v) +} + +func (_s *AgvVehicleStateSelect) sqlScan(ctx context.Context, root *AgvVehicleStateQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(_s.fns)) + for _, fn := range _s.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*_s.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := _s.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (_s *AgvVehicleStateSelect) Modify(modifiers ...func(s *sql.Selector)) *AgvVehicleStateSelect { + _s.modifiers = append(_s.modifiers, modifiers...) + return _s +} diff --git a/bj_power_mes/ent/agvvehiclestate_update.go b/bj_power_mes/ent/agvvehiclestate_update.go new file mode 100644 index 0000000..bc4c15c --- /dev/null +++ b/bj_power_mes/ent/agvvehiclestate_update.go @@ -0,0 +1,471 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "bj_power_mes/ent/agvvehiclestate" + "bj_power_mes/ent/predicate" + "context" + "errors" + "fmt" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// AgvVehicleStateUpdate is the builder for updating AgvVehicleState entities. +type AgvVehicleStateUpdate struct { + config + hooks []Hook + mutation *AgvVehicleStateMutation + modifiers []func(*sql.UpdateBuilder) +} + +// Where appends a list predicates to the AgvVehicleStateUpdate builder. +func (_u *AgvVehicleStateUpdate) Where(ps ...predicate.AgvVehicleState) *AgvVehicleStateUpdate { + _u.mutation.Where(ps...) + return _u +} + +// SetAgvCode sets the "agv_code" field. +func (_u *AgvVehicleStateUpdate) SetAgvCode(v string) *AgvVehicleStateUpdate { + _u.mutation.SetAgvCode(v) + return _u +} + +// SetNillableAgvCode sets the "agv_code" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableAgvCode(v *string) *AgvVehicleStateUpdate { + if v != nil { + _u.SetAgvCode(*v) + } + return _u +} + +// SetHasPallet sets the "has_pallet" field. +func (_u *AgvVehicleStateUpdate) SetHasPallet(v bool) *AgvVehicleStateUpdate { + _u.mutation.SetHasPallet(v) + return _u +} + +// SetNillableHasPallet sets the "has_pallet" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableHasPallet(v *bool) *AgvVehicleStateUpdate { + if v != nil { + _u.SetHasPallet(*v) + } + return _u +} + +// SetSource sets the "source" field. +func (_u *AgvVehicleStateUpdate) SetSource(v string) *AgvVehicleStateUpdate { + _u.mutation.SetSource(v) + return _u +} + +// SetNillableSource sets the "source" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableSource(v *string) *AgvVehicleStateUpdate { + if v != nil { + _u.SetSource(*v) + } + return _u +} + +// SetUpdatedBy sets the "updated_by" field. +func (_u *AgvVehicleStateUpdate) SetUpdatedBy(v string) *AgvVehicleStateUpdate { + _u.mutation.SetUpdatedBy(v) + return _u +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableUpdatedBy(v *string) *AgvVehicleStateUpdate { + if v != nil { + _u.SetUpdatedBy(*v) + } + return _u +} + +// SetUpdatedAt sets the "updated_at" field. +func (_u *AgvVehicleStateUpdate) SetUpdatedAt(v int64) *AgvVehicleStateUpdate { + _u.mutation.ResetUpdatedAt() + _u.mutation.SetUpdatedAt(v) + return _u +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableUpdatedAt(v *int64) *AgvVehicleStateUpdate { + if v != nil { + _u.SetUpdatedAt(*v) + } + return _u +} + +// AddUpdatedAt adds value to the "updated_at" field. +func (_u *AgvVehicleStateUpdate) AddUpdatedAt(v int64) *AgvVehicleStateUpdate { + _u.mutation.AddUpdatedAt(v) + return _u +} + +// SetRemark sets the "remark" field. +func (_u *AgvVehicleStateUpdate) SetRemark(v string) *AgvVehicleStateUpdate { + _u.mutation.SetRemark(v) + return _u +} + +// SetNillableRemark sets the "remark" field if the given value is not nil. +func (_u *AgvVehicleStateUpdate) SetNillableRemark(v *string) *AgvVehicleStateUpdate { + if v != nil { + _u.SetRemark(*v) + } + return _u +} + +// Mutation returns the AgvVehicleStateMutation object of the builder. +func (_u *AgvVehicleStateUpdate) Mutation() *AgvVehicleStateMutation { + return _u.mutation +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (_u *AgvVehicleStateUpdate) Save(ctx context.Context) (int, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AgvVehicleStateUpdate) SaveX(ctx context.Context) int { + affected, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (_u *AgvVehicleStateUpdate) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AgvVehicleStateUpdate) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AgvVehicleStateUpdate) check() error { + if v, ok := _u.mutation.AgvCode(); ok { + if err := agvvehiclestate.AgvCodeValidator(v); err != nil { + return &ValidationError{Name: "agv_code", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.agv_code": %w`, err)} + } + } + if v, ok := _u.mutation.Source(); ok { + if err := agvvehiclestate.SourceValidator(v); err != nil { + return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.source": %w`, err)} + } + } + if v, ok := _u.mutation.UpdatedBy(); ok { + if err := agvvehiclestate.UpdatedByValidator(v); err != nil { + return &ValidationError{Name: "updated_by", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.updated_by": %w`, err)} + } + } + if v, ok := _u.mutation.Remark(); ok { + if err := agvvehiclestate.RemarkValidator(v); err != nil { + return &ValidationError{Name: "remark", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.remark": %w`, err)} + } + } + return nil +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (_u *AgvVehicleStateUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AgvVehicleStateUpdate { + _u.modifiers = append(_u.modifiers, modifiers...) + return _u +} + +func (_u *AgvVehicleStateUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(agvvehiclestate.Table, agvvehiclestate.Columns, sqlgraph.NewFieldSpec(agvvehiclestate.FieldID, field.TypeInt)) + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.AgvCode(); ok { + _spec.SetField(agvvehiclestate.FieldAgvCode, field.TypeString, value) + } + if value, ok := _u.mutation.HasPallet(); ok { + _spec.SetField(agvvehiclestate.FieldHasPallet, field.TypeBool, value) + } + if value, ok := _u.mutation.Source(); ok { + _spec.SetField(agvvehiclestate.FieldSource, field.TypeString, value) + } + if value, ok := _u.mutation.UpdatedBy(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedBy, field.TypeString, value) + } + if value, ok := _u.mutation.UpdatedAt(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedAt, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedUpdatedAt(); ok { + _spec.AddField(agvvehiclestate.FieldUpdatedAt, field.TypeInt64, value) + } + if value, ok := _u.mutation.Remark(); ok { + _spec.SetField(agvvehiclestate.FieldRemark, field.TypeString, value) + } + _spec.AddModifiers(_u.modifiers...) + if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{agvvehiclestate.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + _u.mutation.done = true + return _node, nil +} + +// AgvVehicleStateUpdateOne is the builder for updating a single AgvVehicleState entity. +type AgvVehicleStateUpdateOne struct { + config + fields []string + hooks []Hook + mutation *AgvVehicleStateMutation + modifiers []func(*sql.UpdateBuilder) +} + +// SetAgvCode sets the "agv_code" field. +func (_u *AgvVehicleStateUpdateOne) SetAgvCode(v string) *AgvVehicleStateUpdateOne { + _u.mutation.SetAgvCode(v) + return _u +} + +// SetNillableAgvCode sets the "agv_code" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableAgvCode(v *string) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetAgvCode(*v) + } + return _u +} + +// SetHasPallet sets the "has_pallet" field. +func (_u *AgvVehicleStateUpdateOne) SetHasPallet(v bool) *AgvVehicleStateUpdateOne { + _u.mutation.SetHasPallet(v) + return _u +} + +// SetNillableHasPallet sets the "has_pallet" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableHasPallet(v *bool) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetHasPallet(*v) + } + return _u +} + +// SetSource sets the "source" field. +func (_u *AgvVehicleStateUpdateOne) SetSource(v string) *AgvVehicleStateUpdateOne { + _u.mutation.SetSource(v) + return _u +} + +// SetNillableSource sets the "source" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableSource(v *string) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetSource(*v) + } + return _u +} + +// SetUpdatedBy sets the "updated_by" field. +func (_u *AgvVehicleStateUpdateOne) SetUpdatedBy(v string) *AgvVehicleStateUpdateOne { + _u.mutation.SetUpdatedBy(v) + return _u +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableUpdatedBy(v *string) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetUpdatedBy(*v) + } + return _u +} + +// SetUpdatedAt sets the "updated_at" field. +func (_u *AgvVehicleStateUpdateOne) SetUpdatedAt(v int64) *AgvVehicleStateUpdateOne { + _u.mutation.ResetUpdatedAt() + _u.mutation.SetUpdatedAt(v) + return _u +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableUpdatedAt(v *int64) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetUpdatedAt(*v) + } + return _u +} + +// AddUpdatedAt adds value to the "updated_at" field. +func (_u *AgvVehicleStateUpdateOne) AddUpdatedAt(v int64) *AgvVehicleStateUpdateOne { + _u.mutation.AddUpdatedAt(v) + return _u +} + +// SetRemark sets the "remark" field. +func (_u *AgvVehicleStateUpdateOne) SetRemark(v string) *AgvVehicleStateUpdateOne { + _u.mutation.SetRemark(v) + return _u +} + +// SetNillableRemark sets the "remark" field if the given value is not nil. +func (_u *AgvVehicleStateUpdateOne) SetNillableRemark(v *string) *AgvVehicleStateUpdateOne { + if v != nil { + _u.SetRemark(*v) + } + return _u +} + +// Mutation returns the AgvVehicleStateMutation object of the builder. +func (_u *AgvVehicleStateUpdateOne) Mutation() *AgvVehicleStateMutation { + return _u.mutation +} + +// Where appends a list predicates to the AgvVehicleStateUpdate builder. +func (_u *AgvVehicleStateUpdateOne) Where(ps ...predicate.AgvVehicleState) *AgvVehicleStateUpdateOne { + _u.mutation.Where(ps...) + return _u +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (_u *AgvVehicleStateUpdateOne) Select(field string, fields ...string) *AgvVehicleStateUpdateOne { + _u.fields = append([]string{field}, fields...) + return _u +} + +// Save executes the query and returns the updated AgvVehicleState entity. +func (_u *AgvVehicleStateUpdateOne) Save(ctx context.Context) (*AgvVehicleState, error) { + return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (_u *AgvVehicleStateUpdateOne) SaveX(ctx context.Context) *AgvVehicleState { + node, err := _u.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (_u *AgvVehicleStateUpdateOne) Exec(ctx context.Context) error { + _, err := _u.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (_u *AgvVehicleStateUpdateOne) ExecX(ctx context.Context) { + if err := _u.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (_u *AgvVehicleStateUpdateOne) check() error { + if v, ok := _u.mutation.AgvCode(); ok { + if err := agvvehiclestate.AgvCodeValidator(v); err != nil { + return &ValidationError{Name: "agv_code", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.agv_code": %w`, err)} + } + } + if v, ok := _u.mutation.Source(); ok { + if err := agvvehiclestate.SourceValidator(v); err != nil { + return &ValidationError{Name: "source", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.source": %w`, err)} + } + } + if v, ok := _u.mutation.UpdatedBy(); ok { + if err := agvvehiclestate.UpdatedByValidator(v); err != nil { + return &ValidationError{Name: "updated_by", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.updated_by": %w`, err)} + } + } + if v, ok := _u.mutation.Remark(); ok { + if err := agvvehiclestate.RemarkValidator(v); err != nil { + return &ValidationError{Name: "remark", err: fmt.Errorf(`ent: validator failed for field "AgvVehicleState.remark": %w`, err)} + } + } + return nil +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (_u *AgvVehicleStateUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AgvVehicleStateUpdateOne { + _u.modifiers = append(_u.modifiers, modifiers...) + return _u +} + +func (_u *AgvVehicleStateUpdateOne) sqlSave(ctx context.Context) (_node *AgvVehicleState, err error) { + if err := _u.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(agvvehiclestate.Table, agvvehiclestate.Columns, sqlgraph.NewFieldSpec(agvvehiclestate.FieldID, field.TypeInt)) + id, ok := _u.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "AgvVehicleState.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := _u.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, agvvehiclestate.FieldID) + for _, f := range fields { + if !agvvehiclestate.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != agvvehiclestate.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := _u.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := _u.mutation.AgvCode(); ok { + _spec.SetField(agvvehiclestate.FieldAgvCode, field.TypeString, value) + } + if value, ok := _u.mutation.HasPallet(); ok { + _spec.SetField(agvvehiclestate.FieldHasPallet, field.TypeBool, value) + } + if value, ok := _u.mutation.Source(); ok { + _spec.SetField(agvvehiclestate.FieldSource, field.TypeString, value) + } + if value, ok := _u.mutation.UpdatedBy(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedBy, field.TypeString, value) + } + if value, ok := _u.mutation.UpdatedAt(); ok { + _spec.SetField(agvvehiclestate.FieldUpdatedAt, field.TypeInt64, value) + } + if value, ok := _u.mutation.AddedUpdatedAt(); ok { + _spec.AddField(agvvehiclestate.FieldUpdatedAt, field.TypeInt64, value) + } + if value, ok := _u.mutation.Remark(); ok { + _spec.SetField(agvvehiclestate.FieldRemark, field.TypeString, value) + } + _spec.AddModifiers(_u.modifiers...) + _node = &AgvVehicleState{config: _u.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{agvvehiclestate.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + _u.mutation.done = true + return _node, nil +} diff --git a/bj_power_mes/ent/client.go b/bj_power_mes/ent/client.go index 4461637..763baf2 100644 --- a/bj_power_mes/ent/client.go +++ b/bj_power_mes/ent/client.go @@ -13,6 +13,7 @@ import ( "bj_power_mes/ent/agvpoint" "bj_power_mes/ent/agvtask" + "bj_power_mes/ent/agvvehiclestate" "bj_power_mes/ent/alert" "bj_power_mes/ent/alertrule" "bj_power_mes/ent/associationtrace" @@ -68,6 +69,8 @@ type Client struct { AgvPoint *AgvPointClient // AgvTask is the client for interacting with the AgvTask builders. AgvTask *AgvTaskClient + // AgvVehicleState is the client for interacting with the AgvVehicleState builders. + AgvVehicleState *AgvVehicleStateClient // Alert is the client for interacting with the Alert builders. Alert *AlertClient // AlertRule is the client for interacting with the AlertRule builders. @@ -161,6 +164,7 @@ func (c *Client) init() { c.Schema = migrate.NewSchema(c.driver) c.AgvPoint = NewAgvPointClient(c.config) c.AgvTask = NewAgvTaskClient(c.config) + c.AgvVehicleState = NewAgvVehicleStateClient(c.config) c.Alert = NewAlertClient(c.config) c.AlertRule = NewAlertRuleClient(c.config) c.AssociationTrace = NewAssociationTraceClient(c.config) @@ -295,6 +299,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { config: cfg, AgvPoint: NewAgvPointClient(cfg), AgvTask: NewAgvTaskClient(cfg), + AgvVehicleState: NewAgvVehicleStateClient(cfg), Alert: NewAlertClient(cfg), AlertRule: NewAlertRuleClient(cfg), AssociationTrace: NewAssociationTraceClient(cfg), @@ -356,6 +361,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) config: cfg, AgvPoint: NewAgvPointClient(cfg), AgvTask: NewAgvTaskClient(cfg), + AgvVehicleState: NewAgvVehicleStateClient(cfg), Alert: NewAlertClient(cfg), AlertRule: NewAlertRuleClient(cfg), AssociationTrace: NewAssociationTraceClient(cfg), @@ -425,15 +431,15 @@ func (c *Client) Close() error { // In order to add hooks to a specific client, call: `client.Node.Use(...)`. func (c *Client) Use(hooks ...Hook) { for _, n := range []interface{ Use(...Hook) }{ - c.AgvPoint, c.AgvTask, c.Alert, c.AlertRule, c.AssociationTrace, c.Attachment, - c.BackupRecord, c.CallPool, c.DailyPlan, c.Dock, c.EventLog, c.FlowMaterial, - c.InspectionRecord, c.LinePoint, c.LossLedger, c.Material, c.MaterialQtyReport, - c.MaterialRequest, c.Permission, c.PlcSendLog, c.ProcessFlow, c.ProcessStep, - c.ProductProcess, c.ProductProcessItem, c.Role, c.SemiFlow, c.ShortageRequest, - c.Station, c.StationShift, c.StationState, c.StepCriterion, c.StepData, - c.StepSignRecord, c.SysConfig, c.TorqueRecord, c.User, c.UserStation, - c.WorkOrder, c.Workpiece, c.WorkpieceBind, c.WorkpieceLifecycleLog, - c.WorkpieceProcess, + c.AgvPoint, c.AgvTask, c.AgvVehicleState, c.Alert, c.AlertRule, + c.AssociationTrace, c.Attachment, c.BackupRecord, c.CallPool, c.DailyPlan, + c.Dock, c.EventLog, c.FlowMaterial, c.InspectionRecord, c.LinePoint, + c.LossLedger, c.Material, c.MaterialQtyReport, c.MaterialRequest, c.Permission, + c.PlcSendLog, c.ProcessFlow, c.ProcessStep, c.ProductProcess, + c.ProductProcessItem, c.Role, c.SemiFlow, c.ShortageRequest, c.Station, + c.StationShift, c.StationState, c.StepCriterion, c.StepData, c.StepSignRecord, + c.SysConfig, c.TorqueRecord, c.User, c.UserStation, c.WorkOrder, c.Workpiece, + c.WorkpieceBind, c.WorkpieceLifecycleLog, c.WorkpieceProcess, } { n.Use(hooks...) } @@ -443,15 +449,15 @@ func (c *Client) Use(hooks ...Hook) { // In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`. func (c *Client) Intercept(interceptors ...Interceptor) { for _, n := range []interface{ Intercept(...Interceptor) }{ - c.AgvPoint, c.AgvTask, c.Alert, c.AlertRule, c.AssociationTrace, c.Attachment, - c.BackupRecord, c.CallPool, c.DailyPlan, c.Dock, c.EventLog, c.FlowMaterial, - c.InspectionRecord, c.LinePoint, c.LossLedger, c.Material, c.MaterialQtyReport, - c.MaterialRequest, c.Permission, c.PlcSendLog, c.ProcessFlow, c.ProcessStep, - c.ProductProcess, c.ProductProcessItem, c.Role, c.SemiFlow, c.ShortageRequest, - c.Station, c.StationShift, c.StationState, c.StepCriterion, c.StepData, - c.StepSignRecord, c.SysConfig, c.TorqueRecord, c.User, c.UserStation, - c.WorkOrder, c.Workpiece, c.WorkpieceBind, c.WorkpieceLifecycleLog, - c.WorkpieceProcess, + c.AgvPoint, c.AgvTask, c.AgvVehicleState, c.Alert, c.AlertRule, + c.AssociationTrace, c.Attachment, c.BackupRecord, c.CallPool, c.DailyPlan, + c.Dock, c.EventLog, c.FlowMaterial, c.InspectionRecord, c.LinePoint, + c.LossLedger, c.Material, c.MaterialQtyReport, c.MaterialRequest, c.Permission, + c.PlcSendLog, c.ProcessFlow, c.ProcessStep, c.ProductProcess, + c.ProductProcessItem, c.Role, c.SemiFlow, c.ShortageRequest, c.Station, + c.StationShift, c.StationState, c.StepCriterion, c.StepData, c.StepSignRecord, + c.SysConfig, c.TorqueRecord, c.User, c.UserStation, c.WorkOrder, c.Workpiece, + c.WorkpieceBind, c.WorkpieceLifecycleLog, c.WorkpieceProcess, } { n.Intercept(interceptors...) } @@ -464,6 +470,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { return c.AgvPoint.mutate(ctx, m) case *AgvTaskMutation: return c.AgvTask.mutate(ctx, m) + case *AgvVehicleStateMutation: + return c.AgvVehicleState.mutate(ctx, m) case *AlertMutation: return c.Alert.mutate(ctx, m) case *AlertRuleMutation: @@ -815,6 +823,139 @@ func (c *AgvTaskClient) mutate(ctx context.Context, m *AgvTaskMutation) (Value, } } +// AgvVehicleStateClient is a client for the AgvVehicleState schema. +type AgvVehicleStateClient struct { + config +} + +// NewAgvVehicleStateClient returns a client for the AgvVehicleState from the given config. +func NewAgvVehicleStateClient(c config) *AgvVehicleStateClient { + return &AgvVehicleStateClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `agvvehiclestate.Hooks(f(g(h())))`. +func (c *AgvVehicleStateClient) Use(hooks ...Hook) { + c.hooks.AgvVehicleState = append(c.hooks.AgvVehicleState, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `agvvehiclestate.Intercept(f(g(h())))`. +func (c *AgvVehicleStateClient) Intercept(interceptors ...Interceptor) { + c.inters.AgvVehicleState = append(c.inters.AgvVehicleState, interceptors...) +} + +// Create returns a builder for creating a AgvVehicleState entity. +func (c *AgvVehicleStateClient) Create() *AgvVehicleStateCreate { + mutation := newAgvVehicleStateMutation(c.config, OpCreate) + return &AgvVehicleStateCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of AgvVehicleState entities. +func (c *AgvVehicleStateClient) CreateBulk(builders ...*AgvVehicleStateCreate) *AgvVehicleStateCreateBulk { + return &AgvVehicleStateCreateBulk{config: c.config, builders: builders} +} + +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *AgvVehicleStateClient) MapCreateBulk(slice any, setFunc func(*AgvVehicleStateCreate, int)) *AgvVehicleStateCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &AgvVehicleStateCreateBulk{err: fmt.Errorf("calling to AgvVehicleStateClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*AgvVehicleStateCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &AgvVehicleStateCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for AgvVehicleState. +func (c *AgvVehicleStateClient) Update() *AgvVehicleStateUpdate { + mutation := newAgvVehicleStateMutation(c.config, OpUpdate) + return &AgvVehicleStateUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *AgvVehicleStateClient) UpdateOne(_m *AgvVehicleState) *AgvVehicleStateUpdateOne { + mutation := newAgvVehicleStateMutation(c.config, OpUpdateOne, withAgvVehicleState(_m)) + return &AgvVehicleStateUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *AgvVehicleStateClient) UpdateOneID(id int) *AgvVehicleStateUpdateOne { + mutation := newAgvVehicleStateMutation(c.config, OpUpdateOne, withAgvVehicleStateID(id)) + return &AgvVehicleStateUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for AgvVehicleState. +func (c *AgvVehicleStateClient) Delete() *AgvVehicleStateDelete { + mutation := newAgvVehicleStateMutation(c.config, OpDelete) + return &AgvVehicleStateDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *AgvVehicleStateClient) DeleteOne(_m *AgvVehicleState) *AgvVehicleStateDeleteOne { + return c.DeleteOneID(_m.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *AgvVehicleStateClient) DeleteOneID(id int) *AgvVehicleStateDeleteOne { + builder := c.Delete().Where(agvvehiclestate.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &AgvVehicleStateDeleteOne{builder} +} + +// Query returns a query builder for AgvVehicleState. +func (c *AgvVehicleStateClient) Query() *AgvVehicleStateQuery { + return &AgvVehicleStateQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeAgvVehicleState}, + inters: c.Interceptors(), + } +} + +// Get returns a AgvVehicleState entity by its id. +func (c *AgvVehicleStateClient) Get(ctx context.Context, id int) (*AgvVehicleState, error) { + return c.Query().Where(agvvehiclestate.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *AgvVehicleStateClient) GetX(ctx context.Context, id int) *AgvVehicleState { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// Hooks returns the client hooks. +func (c *AgvVehicleStateClient) Hooks() []Hook { + return c.hooks.AgvVehicleState +} + +// Interceptors returns the client interceptors. +func (c *AgvVehicleStateClient) Interceptors() []Interceptor { + return c.inters.AgvVehicleState +} + +func (c *AgvVehicleStateClient) mutate(ctx context.Context, m *AgvVehicleStateMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&AgvVehicleStateCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&AgvVehicleStateUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&AgvVehicleStateUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&AgvVehicleStateDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown AgvVehicleState mutation op: %q", m.Op()) + } +} + // AlertClient is a client for the Alert schema. type AlertClient struct { config @@ -6138,23 +6279,23 @@ func (c *WorkpieceProcessClient) mutate(ctx context.Context, m *WorkpieceProcess // hooks and interceptors per client, for fast access. type ( hooks struct { - AgvPoint, AgvTask, Alert, AlertRule, AssociationTrace, Attachment, BackupRecord, - CallPool, DailyPlan, Dock, EventLog, FlowMaterial, InspectionRecord, LinePoint, - LossLedger, Material, MaterialQtyReport, MaterialRequest, Permission, - PlcSendLog, ProcessFlow, ProcessStep, ProductProcess, ProductProcessItem, Role, - SemiFlow, ShortageRequest, Station, StationShift, StationState, StepCriterion, - StepData, StepSignRecord, SysConfig, TorqueRecord, User, UserStation, - WorkOrder, Workpiece, WorkpieceBind, WorkpieceLifecycleLog, - WorkpieceProcess []ent.Hook + AgvPoint, AgvTask, AgvVehicleState, Alert, AlertRule, AssociationTrace, + Attachment, BackupRecord, CallPool, DailyPlan, Dock, EventLog, FlowMaterial, + InspectionRecord, LinePoint, LossLedger, Material, MaterialQtyReport, + MaterialRequest, Permission, PlcSendLog, ProcessFlow, ProcessStep, + ProductProcess, ProductProcessItem, Role, SemiFlow, ShortageRequest, Station, + StationShift, StationState, StepCriterion, StepData, StepSignRecord, SysConfig, + TorqueRecord, User, UserStation, WorkOrder, Workpiece, WorkpieceBind, + WorkpieceLifecycleLog, WorkpieceProcess []ent.Hook } inters struct { - AgvPoint, AgvTask, Alert, AlertRule, AssociationTrace, Attachment, BackupRecord, - CallPool, DailyPlan, Dock, EventLog, FlowMaterial, InspectionRecord, LinePoint, - LossLedger, Material, MaterialQtyReport, MaterialRequest, Permission, - PlcSendLog, ProcessFlow, ProcessStep, ProductProcess, ProductProcessItem, Role, - SemiFlow, ShortageRequest, Station, StationShift, StationState, StepCriterion, - StepData, StepSignRecord, SysConfig, TorqueRecord, User, UserStation, - WorkOrder, Workpiece, WorkpieceBind, WorkpieceLifecycleLog, - WorkpieceProcess []ent.Interceptor + AgvPoint, AgvTask, AgvVehicleState, Alert, AlertRule, AssociationTrace, + Attachment, BackupRecord, CallPool, DailyPlan, Dock, EventLog, FlowMaterial, + InspectionRecord, LinePoint, LossLedger, Material, MaterialQtyReport, + MaterialRequest, Permission, PlcSendLog, ProcessFlow, ProcessStep, + ProductProcess, ProductProcessItem, Role, SemiFlow, ShortageRequest, Station, + StationShift, StationState, StepCriterion, StepData, StepSignRecord, SysConfig, + TorqueRecord, User, UserStation, WorkOrder, Workpiece, WorkpieceBind, + WorkpieceLifecycleLog, WorkpieceProcess []ent.Interceptor } ) diff --git a/bj_power_mes/ent/dock.go b/bj_power_mes/ent/dock.go index e7555c0..6b28189 100644 --- a/bj_power_mes/ent/dock.go +++ b/bj_power_mes/ent/dock.go @@ -12,7 +12,7 @@ import ( "entgo.io/ent/dialect/sql" ) -// Dock 接驳台主数据:DOCK01~DOCK20(产线,DOCKn↔工位n)+ DOCK21(库房收货)。 +// Dock 接驳台主数据:DOCK01~DOCK20(产线,DOCKn↔工位n)+ JBT21(库房收货;T7 2026-11-03 统一代号)。 type Dock struct { config `json:"-"` // ID of the ent. diff --git a/bj_power_mes/ent/ent.go b/bj_power_mes/ent/ent.go index 4b46d76..8a4d9f7 100644 --- a/bj_power_mes/ent/ent.go +++ b/bj_power_mes/ent/ent.go @@ -5,6 +5,7 @@ package ent import ( "bj_power_mes/ent/agvpoint" "bj_power_mes/ent/agvtask" + "bj_power_mes/ent/agvvehiclestate" "bj_power_mes/ent/alert" "bj_power_mes/ent/alertrule" "bj_power_mes/ent/associationtrace" @@ -116,6 +117,7 @@ func checkColumn(t, c string) error { columnCheck = sql.NewColumnCheck(map[string]func(string) bool{ agvpoint.Table: agvpoint.ValidColumn, agvtask.Table: agvtask.ValidColumn, + agvvehiclestate.Table: agvvehiclestate.ValidColumn, alert.Table: alert.ValidColumn, alertrule.Table: alertrule.ValidColumn, associationtrace.Table: associationtrace.ValidColumn, diff --git a/bj_power_mes/ent/flowmaterial.go b/bj_power_mes/ent/flowmaterial.go index 092ddda..2c2a635 100644 --- a/bj_power_mes/ent/flowmaterial.go +++ b/bj_power_mes/ent/flowmaterial.go @@ -31,7 +31,7 @@ type FlowMaterial struct { SnMode int `json:"snMode,omitempty"` // 单台用量 UnitQty float64 `json:"unitQty,omitempty"` - // 损耗率% + // 损耗率%(仅展示口径,不参与备料计算——R7 2026-11-03 拍板:备料量=工单需求×单台用量,损耗走补料审批) LossRate float64 `json:"lossRate,omitempty"` // CreatedAt holds the value of the "createdAt" field. CreatedAt time.Time `json:"createdAt,omitempty"` diff --git a/bj_power_mes/ent/hook/hook.go b/bj_power_mes/ent/hook/hook.go index 69cceef..97bfe5b 100644 --- a/bj_power_mes/ent/hook/hook.go +++ b/bj_power_mes/ent/hook/hook.go @@ -32,6 +32,18 @@ func (f AgvTaskFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, err return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AgvTaskMutation", m) } +// The AgvVehicleStateFunc type is an adapter to allow the use of ordinary +// function as AgvVehicleState mutator. +type AgvVehicleStateFunc func(context.Context, *ent.AgvVehicleStateMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f AgvVehicleStateFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.AgvVehicleStateMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.AgvVehicleStateMutation", m) +} + // 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) diff --git a/bj_power_mes/ent/materialrequest.go b/bj_power_mes/ent/materialrequest.go index 2b1d28b..6662452 100644 --- a/bj_power_mes/ent/materialrequest.go +++ b/bj_power_mes/ent/materialrequest.go @@ -68,6 +68,12 @@ type MaterialRequest struct { LossQty *float64 `json:"lossQty,omitempty"` // 损耗原因(有损耗时必填,主管在损耗台账批注) LossReason string `json:"lossReason,omitempty"` + // 库管实收量(WMS 确认收货回写) + ReceiveQty *float64 `json:"receiveQty,omitempty"` + // 收货差异=应退-实收(>0 为少收,记待核,不自动进损耗台账) + ReceiveDiff *float64 `json:"receiveDiff,omitempty"` + // 收货差异备注(库管填写,说明差异原因) + ReceiveNote string `json:"receiveNote,omitempty"` // CreatedAt holds the value of the "createdAt" field. CreatedAt time.Time `json:"createdAt,omitempty"` // UpdatedAt holds the value of the "updatedAt" field. @@ -84,11 +90,11 @@ func (*MaterialRequest) scanValues(columns []string) ([]any, error) { values[i] = new([]byte) case materialrequest.FieldNeedAgv, materialrequest.FieldCrossDay: values[i] = new(sql.NullBool) - case materialrequest.FieldReqQty, materialrequest.FieldSentQty, materialrequest.FieldReturnedQty, materialrequest.FieldTheoryQty, materialrequest.FieldLossQty: + case materialrequest.FieldReqQty, materialrequest.FieldSentQty, materialrequest.FieldReturnedQty, materialrequest.FieldTheoryQty, materialrequest.FieldLossQty, materialrequest.FieldReceiveQty, materialrequest.FieldReceiveDiff: values[i] = new(sql.NullFloat64) case materialrequest.FieldID, materialrequest.FieldSnMode, materialrequest.FieldStationNo: values[i] = new(sql.NullInt64) - case materialrequest.FieldRequestNo, materialrequest.FieldMaterialCode, materialrequest.FieldMaterialName, materialrequest.FieldUnit, materialrequest.FieldStatus, materialrequest.FieldTargetDock, materialrequest.FieldSource, materialrequest.FieldRefReportNo, materialrequest.FieldAgvTaskNo, materialrequest.FieldOutboundNo, materialrequest.FieldRejectReason, materialrequest.FieldOperator, materialrequest.FieldWorkOrderNo, materialrequest.FieldReturnDock, materialrequest.FieldLossReason: + case materialrequest.FieldRequestNo, materialrequest.FieldMaterialCode, materialrequest.FieldMaterialName, materialrequest.FieldUnit, materialrequest.FieldStatus, materialrequest.FieldTargetDock, materialrequest.FieldSource, materialrequest.FieldRefReportNo, materialrequest.FieldAgvTaskNo, materialrequest.FieldOutboundNo, materialrequest.FieldRejectReason, materialrequest.FieldOperator, materialrequest.FieldWorkOrderNo, materialrequest.FieldReturnDock, materialrequest.FieldLossReason, materialrequest.FieldReceiveNote: values[i] = new(sql.NullString) case materialrequest.FieldCreatedAt, materialrequest.FieldUpdatedAt: values[i] = new(sql.NullTime) @@ -267,6 +273,26 @@ func (_m *MaterialRequest) assignValues(columns []string, values []any) error { } else if value.Valid { _m.LossReason = value.String } + case materialrequest.FieldReceiveQty: + if value, ok := values[i].(*sql.NullFloat64); !ok { + return fmt.Errorf("unexpected type %T for field receiveQty", values[i]) + } else if value.Valid { + _m.ReceiveQty = new(float64) + *_m.ReceiveQty = value.Float64 + } + case materialrequest.FieldReceiveDiff: + if value, ok := values[i].(*sql.NullFloat64); !ok { + return fmt.Errorf("unexpected type %T for field receiveDiff", values[i]) + } else if value.Valid { + _m.ReceiveDiff = new(float64) + *_m.ReceiveDiff = value.Float64 + } + case materialrequest.FieldReceiveNote: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field receiveNote", values[i]) + } else if value.Valid { + _m.ReceiveNote = value.String + } case materialrequest.FieldCreatedAt: if value, ok := values[i].(*sql.NullTime); !ok { return fmt.Errorf("unexpected type %T for field createdAt", values[i]) @@ -395,6 +421,19 @@ func (_m *MaterialRequest) String() string { builder.WriteString("lossReason=") builder.WriteString(_m.LossReason) builder.WriteString(", ") + if v := _m.ReceiveQty; v != nil { + builder.WriteString("receiveQty=") + builder.WriteString(fmt.Sprintf("%v", *v)) + } + builder.WriteString(", ") + if v := _m.ReceiveDiff; v != nil { + builder.WriteString("receiveDiff=") + builder.WriteString(fmt.Sprintf("%v", *v)) + } + builder.WriteString(", ") + builder.WriteString("receiveNote=") + builder.WriteString(_m.ReceiveNote) + builder.WriteString(", ") builder.WriteString("createdAt=") builder.WriteString(_m.CreatedAt.Format(time.ANSIC)) builder.WriteString(", ") diff --git a/bj_power_mes/ent/materialrequest/materialrequest.go b/bj_power_mes/ent/materialrequest/materialrequest.go index ea7697e..2ea5f4d 100644 --- a/bj_power_mes/ent/materialrequest/materialrequest.go +++ b/bj_power_mes/ent/materialrequest/materialrequest.go @@ -63,6 +63,12 @@ const ( FieldLossQty = "loss_qty" // FieldLossReason holds the string denoting the lossreason field in the database. FieldLossReason = "loss_reason" + // FieldReceiveQty holds the string denoting the receiveqty field in the database. + FieldReceiveQty = "receive_qty" + // FieldReceiveDiff holds the string denoting the receivediff field in the database. + FieldReceiveDiff = "receive_diff" + // FieldReceiveNote holds the string denoting the receivenote field in the database. + FieldReceiveNote = "receive_note" // FieldCreatedAt holds the string denoting the createdat field in the database. FieldCreatedAt = "created_at" // FieldUpdatedAt holds the string denoting the updatedat field in the database. @@ -99,6 +105,9 @@ var Columns = []string{ FieldTheoryQty, FieldLossQty, FieldLossReason, + FieldReceiveQty, + FieldReceiveDiff, + FieldReceiveNote, FieldCreatedAt, FieldUpdatedAt, } @@ -184,6 +193,10 @@ var ( DefaultLossReason string // LossReasonValidator is a validator for the "lossReason" field. It is called by the builders before save. LossReasonValidator func(string) error + // DefaultReceiveNote holds the default value on creation for the "receiveNote" field. + DefaultReceiveNote string + // ReceiveNoteValidator is a validator for the "receiveNote" field. It is called by the builders before save. + ReceiveNoteValidator func(string) error // DefaultCreatedAt holds the default value on creation for the "createdAt" field. DefaultCreatedAt func() time.Time // DefaultUpdatedAt holds the default value on creation for the "updatedAt" field. @@ -322,6 +335,21 @@ func ByLossReason(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldLossReason, opts...).ToFunc() } +// ByReceiveQty orders the results by the receiveQty field. +func ByReceiveQty(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldReceiveQty, opts...).ToFunc() +} + +// ByReceiveDiff orders the results by the receiveDiff field. +func ByReceiveDiff(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldReceiveDiff, opts...).ToFunc() +} + +// ByReceiveNote orders the results by the receiveNote field. +func ByReceiveNote(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldReceiveNote, opts...).ToFunc() +} + // ByCreatedAt orders the results by the createdAt field. func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() diff --git a/bj_power_mes/ent/materialrequest/where.go b/bj_power_mes/ent/materialrequest/where.go index 67a900a..067ab86 100644 --- a/bj_power_mes/ent/materialrequest/where.go +++ b/bj_power_mes/ent/materialrequest/where.go @@ -174,6 +174,21 @@ func LossReason(v string) predicate.MaterialRequest { return predicate.MaterialRequest(sql.FieldEQ(FieldLossReason, v)) } +// ReceiveQty applies equality check predicate on the "receiveQty" field. It's identical to ReceiveQtyEQ. +func ReceiveQty(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveQty, v)) +} + +// ReceiveDiff applies equality check predicate on the "receiveDiff" field. It's identical to ReceiveDiffEQ. +func ReceiveDiff(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveDiff, v)) +} + +// ReceiveNote applies equality check predicate on the "receiveNote" field. It's identical to ReceiveNoteEQ. +func ReceiveNote(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveNote, v)) +} + // CreatedAt applies equality check predicate on the "createdAt" field. It's identical to CreatedAtEQ. func CreatedAt(v time.Time) predicate.MaterialRequest { return predicate.MaterialRequest(sql.FieldEQ(FieldCreatedAt, v)) @@ -1489,6 +1504,171 @@ func LossReasonContainsFold(v string) predicate.MaterialRequest { return predicate.MaterialRequest(sql.FieldContainsFold(FieldLossReason, v)) } +// ReceiveQtyEQ applies the EQ predicate on the "receiveQty" field. +func ReceiveQtyEQ(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveQty, v)) +} + +// ReceiveQtyNEQ applies the NEQ predicate on the "receiveQty" field. +func ReceiveQtyNEQ(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNEQ(FieldReceiveQty, v)) +} + +// ReceiveQtyIn applies the In predicate on the "receiveQty" field. +func ReceiveQtyIn(vs ...float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldIn(FieldReceiveQty, vs...)) +} + +// ReceiveQtyNotIn applies the NotIn predicate on the "receiveQty" field. +func ReceiveQtyNotIn(vs ...float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNotIn(FieldReceiveQty, vs...)) +} + +// ReceiveQtyGT applies the GT predicate on the "receiveQty" field. +func ReceiveQtyGT(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGT(FieldReceiveQty, v)) +} + +// ReceiveQtyGTE applies the GTE predicate on the "receiveQty" field. +func ReceiveQtyGTE(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGTE(FieldReceiveQty, v)) +} + +// ReceiveQtyLT applies the LT predicate on the "receiveQty" field. +func ReceiveQtyLT(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLT(FieldReceiveQty, v)) +} + +// ReceiveQtyLTE applies the LTE predicate on the "receiveQty" field. +func ReceiveQtyLTE(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLTE(FieldReceiveQty, v)) +} + +// ReceiveQtyIsNil applies the IsNil predicate on the "receiveQty" field. +func ReceiveQtyIsNil() predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldIsNull(FieldReceiveQty)) +} + +// ReceiveQtyNotNil applies the NotNil predicate on the "receiveQty" field. +func ReceiveQtyNotNil() predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNotNull(FieldReceiveQty)) +} + +// ReceiveDiffEQ applies the EQ predicate on the "receiveDiff" field. +func ReceiveDiffEQ(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveDiff, v)) +} + +// ReceiveDiffNEQ applies the NEQ predicate on the "receiveDiff" field. +func ReceiveDiffNEQ(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNEQ(FieldReceiveDiff, v)) +} + +// ReceiveDiffIn applies the In predicate on the "receiveDiff" field. +func ReceiveDiffIn(vs ...float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldIn(FieldReceiveDiff, vs...)) +} + +// ReceiveDiffNotIn applies the NotIn predicate on the "receiveDiff" field. +func ReceiveDiffNotIn(vs ...float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNotIn(FieldReceiveDiff, vs...)) +} + +// ReceiveDiffGT applies the GT predicate on the "receiveDiff" field. +func ReceiveDiffGT(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGT(FieldReceiveDiff, v)) +} + +// ReceiveDiffGTE applies the GTE predicate on the "receiveDiff" field. +func ReceiveDiffGTE(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGTE(FieldReceiveDiff, v)) +} + +// ReceiveDiffLT applies the LT predicate on the "receiveDiff" field. +func ReceiveDiffLT(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLT(FieldReceiveDiff, v)) +} + +// ReceiveDiffLTE applies the LTE predicate on the "receiveDiff" field. +func ReceiveDiffLTE(v float64) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLTE(FieldReceiveDiff, v)) +} + +// ReceiveDiffIsNil applies the IsNil predicate on the "receiveDiff" field. +func ReceiveDiffIsNil() predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldIsNull(FieldReceiveDiff)) +} + +// ReceiveDiffNotNil applies the NotNil predicate on the "receiveDiff" field. +func ReceiveDiffNotNil() predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNotNull(FieldReceiveDiff)) +} + +// ReceiveNoteEQ applies the EQ predicate on the "receiveNote" field. +func ReceiveNoteEQ(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEQ(FieldReceiveNote, v)) +} + +// ReceiveNoteNEQ applies the NEQ predicate on the "receiveNote" field. +func ReceiveNoteNEQ(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNEQ(FieldReceiveNote, v)) +} + +// ReceiveNoteIn applies the In predicate on the "receiveNote" field. +func ReceiveNoteIn(vs ...string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldIn(FieldReceiveNote, vs...)) +} + +// ReceiveNoteNotIn applies the NotIn predicate on the "receiveNote" field. +func ReceiveNoteNotIn(vs ...string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldNotIn(FieldReceiveNote, vs...)) +} + +// ReceiveNoteGT applies the GT predicate on the "receiveNote" field. +func ReceiveNoteGT(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGT(FieldReceiveNote, v)) +} + +// ReceiveNoteGTE applies the GTE predicate on the "receiveNote" field. +func ReceiveNoteGTE(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldGTE(FieldReceiveNote, v)) +} + +// ReceiveNoteLT applies the LT predicate on the "receiveNote" field. +func ReceiveNoteLT(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLT(FieldReceiveNote, v)) +} + +// ReceiveNoteLTE applies the LTE predicate on the "receiveNote" field. +func ReceiveNoteLTE(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldLTE(FieldReceiveNote, v)) +} + +// ReceiveNoteContains applies the Contains predicate on the "receiveNote" field. +func ReceiveNoteContains(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldContains(FieldReceiveNote, v)) +} + +// ReceiveNoteHasPrefix applies the HasPrefix predicate on the "receiveNote" field. +func ReceiveNoteHasPrefix(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldHasPrefix(FieldReceiveNote, v)) +} + +// ReceiveNoteHasSuffix applies the HasSuffix predicate on the "receiveNote" field. +func ReceiveNoteHasSuffix(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldHasSuffix(FieldReceiveNote, v)) +} + +// ReceiveNoteEqualFold applies the EqualFold predicate on the "receiveNote" field. +func ReceiveNoteEqualFold(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldEqualFold(FieldReceiveNote, v)) +} + +// ReceiveNoteContainsFold applies the ContainsFold predicate on the "receiveNote" field. +func ReceiveNoteContainsFold(v string) predicate.MaterialRequest { + return predicate.MaterialRequest(sql.FieldContainsFold(FieldReceiveNote, v)) +} + // CreatedAtEQ applies the EQ predicate on the "createdAt" field. func CreatedAtEQ(v time.Time) predicate.MaterialRequest { return predicate.MaterialRequest(sql.FieldEQ(FieldCreatedAt, v)) diff --git a/bj_power_mes/ent/materialrequest_create.go b/bj_power_mes/ent/materialrequest_create.go index 1c9a1c5..dfc4abd 100644 --- a/bj_power_mes/ent/materialrequest_create.go +++ b/bj_power_mes/ent/materialrequest_create.go @@ -346,6 +346,48 @@ func (_c *MaterialRequestCreate) SetNillableLossReason(v *string) *MaterialReque return _c } +// SetReceiveQty sets the "receiveQty" field. +func (_c *MaterialRequestCreate) SetReceiveQty(v float64) *MaterialRequestCreate { + _c.mutation.SetReceiveQty(v) + return _c +} + +// SetNillableReceiveQty sets the "receiveQty" field if the given value is not nil. +func (_c *MaterialRequestCreate) SetNillableReceiveQty(v *float64) *MaterialRequestCreate { + if v != nil { + _c.SetReceiveQty(*v) + } + return _c +} + +// SetReceiveDiff sets the "receiveDiff" field. +func (_c *MaterialRequestCreate) SetReceiveDiff(v float64) *MaterialRequestCreate { + _c.mutation.SetReceiveDiff(v) + return _c +} + +// SetNillableReceiveDiff sets the "receiveDiff" field if the given value is not nil. +func (_c *MaterialRequestCreate) SetNillableReceiveDiff(v *float64) *MaterialRequestCreate { + if v != nil { + _c.SetReceiveDiff(*v) + } + return _c +} + +// SetReceiveNote sets the "receiveNote" field. +func (_c *MaterialRequestCreate) SetReceiveNote(v string) *MaterialRequestCreate { + _c.mutation.SetReceiveNote(v) + return _c +} + +// SetNillableReceiveNote sets the "receiveNote" field if the given value is not nil. +func (_c *MaterialRequestCreate) SetNillableReceiveNote(v *string) *MaterialRequestCreate { + if v != nil { + _c.SetReceiveNote(*v) + } + return _c +} + // SetCreatedAt sets the "createdAt" field. func (_c *MaterialRequestCreate) SetCreatedAt(v time.Time) *MaterialRequestCreate { _c.mutation.SetCreatedAt(v) @@ -495,6 +537,10 @@ func (_c *MaterialRequestCreate) defaults() { v := materialrequest.DefaultLossReason _c.mutation.SetLossReason(v) } + if _, ok := _c.mutation.ReceiveNote(); !ok { + v := materialrequest.DefaultReceiveNote + _c.mutation.SetReceiveNote(v) + } if _, ok := _c.mutation.CreatedAt(); !ok { v := materialrequest.DefaultCreatedAt() _c.mutation.SetCreatedAt(v) @@ -648,6 +694,14 @@ func (_c *MaterialRequestCreate) check() error { return &ValidationError{Name: "lossReason", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.lossReason": %w`, err)} } } + if _, ok := _c.mutation.ReceiveNote(); !ok { + return &ValidationError{Name: "receiveNote", err: errors.New(`ent: missing required field "MaterialRequest.receiveNote"`)} + } + if v, ok := _c.mutation.ReceiveNote(); ok { + if err := materialrequest.ReceiveNoteValidator(v); err != nil { + return &ValidationError{Name: "receiveNote", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.receiveNote": %w`, err)} + } + } if _, ok := _c.mutation.CreatedAt(); !ok { return &ValidationError{Name: "createdAt", err: errors.New(`ent: missing required field "MaterialRequest.createdAt"`)} } @@ -788,6 +842,18 @@ func (_c *MaterialRequestCreate) createSpec() (*MaterialRequest, *sqlgraph.Creat _spec.SetField(materialrequest.FieldLossReason, field.TypeString, value) _node.LossReason = value } + if value, ok := _c.mutation.ReceiveQty(); ok { + _spec.SetField(materialrequest.FieldReceiveQty, field.TypeFloat64, value) + _node.ReceiveQty = &value + } + if value, ok := _c.mutation.ReceiveDiff(); ok { + _spec.SetField(materialrequest.FieldReceiveDiff, field.TypeFloat64, value) + _node.ReceiveDiff = &value + } + if value, ok := _c.mutation.ReceiveNote(); ok { + _spec.SetField(materialrequest.FieldReceiveNote, field.TypeString, value) + _node.ReceiveNote = value + } if value, ok := _c.mutation.CreatedAt(); ok { _spec.SetField(materialrequest.FieldCreatedAt, field.TypeTime, value) _node.CreatedAt = value diff --git a/bj_power_mes/ent/materialrequest_update.go b/bj_power_mes/ent/materialrequest_update.go index f1e1f3e..35acf95 100644 --- a/bj_power_mes/ent/materialrequest_update.go +++ b/bj_power_mes/ent/materialrequest_update.go @@ -438,6 +438,74 @@ func (_u *MaterialRequestUpdate) SetNillableLossReason(v *string) *MaterialReque return _u } +// SetReceiveQty sets the "receiveQty" field. +func (_u *MaterialRequestUpdate) SetReceiveQty(v float64) *MaterialRequestUpdate { + _u.mutation.ResetReceiveQty() + _u.mutation.SetReceiveQty(v) + return _u +} + +// SetNillableReceiveQty sets the "receiveQty" field if the given value is not nil. +func (_u *MaterialRequestUpdate) SetNillableReceiveQty(v *float64) *MaterialRequestUpdate { + if v != nil { + _u.SetReceiveQty(*v) + } + return _u +} + +// AddReceiveQty adds value to the "receiveQty" field. +func (_u *MaterialRequestUpdate) AddReceiveQty(v float64) *MaterialRequestUpdate { + _u.mutation.AddReceiveQty(v) + return _u +} + +// ClearReceiveQty clears the value of the "receiveQty" field. +func (_u *MaterialRequestUpdate) ClearReceiveQty() *MaterialRequestUpdate { + _u.mutation.ClearReceiveQty() + return _u +} + +// SetReceiveDiff sets the "receiveDiff" field. +func (_u *MaterialRequestUpdate) SetReceiveDiff(v float64) *MaterialRequestUpdate { + _u.mutation.ResetReceiveDiff() + _u.mutation.SetReceiveDiff(v) + return _u +} + +// SetNillableReceiveDiff sets the "receiveDiff" field if the given value is not nil. +func (_u *MaterialRequestUpdate) SetNillableReceiveDiff(v *float64) *MaterialRequestUpdate { + if v != nil { + _u.SetReceiveDiff(*v) + } + return _u +} + +// AddReceiveDiff adds value to the "receiveDiff" field. +func (_u *MaterialRequestUpdate) AddReceiveDiff(v float64) *MaterialRequestUpdate { + _u.mutation.AddReceiveDiff(v) + return _u +} + +// ClearReceiveDiff clears the value of the "receiveDiff" field. +func (_u *MaterialRequestUpdate) ClearReceiveDiff() *MaterialRequestUpdate { + _u.mutation.ClearReceiveDiff() + return _u +} + +// SetReceiveNote sets the "receiveNote" field. +func (_u *MaterialRequestUpdate) SetReceiveNote(v string) *MaterialRequestUpdate { + _u.mutation.SetReceiveNote(v) + return _u +} + +// SetNillableReceiveNote sets the "receiveNote" field if the given value is not nil. +func (_u *MaterialRequestUpdate) SetNillableReceiveNote(v *string) *MaterialRequestUpdate { + if v != nil { + _u.SetReceiveNote(*v) + } + return _u +} + // SetUpdatedAt sets the "updatedAt" field. func (_u *MaterialRequestUpdate) SetUpdatedAt(v time.Time) *MaterialRequestUpdate { _u.mutation.SetUpdatedAt(v) @@ -568,6 +636,11 @@ func (_u *MaterialRequestUpdate) check() error { return &ValidationError{Name: "lossReason", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.lossReason": %w`, err)} } } + if v, ok := _u.mutation.ReceiveNote(); ok { + if err := materialrequest.ReceiveNoteValidator(v); err != nil { + return &ValidationError{Name: "receiveNote", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.receiveNote": %w`, err)} + } + } return nil } @@ -694,6 +767,27 @@ func (_u *MaterialRequestUpdate) sqlSave(ctx context.Context) (_node int, err er if value, ok := _u.mutation.LossReason(); ok { _spec.SetField(materialrequest.FieldLossReason, field.TypeString, value) } + if value, ok := _u.mutation.ReceiveQty(); ok { + _spec.SetField(materialrequest.FieldReceiveQty, field.TypeFloat64, value) + } + if value, ok := _u.mutation.AddedReceiveQty(); ok { + _spec.AddField(materialrequest.FieldReceiveQty, field.TypeFloat64, value) + } + if _u.mutation.ReceiveQtyCleared() { + _spec.ClearField(materialrequest.FieldReceiveQty, field.TypeFloat64) + } + if value, ok := _u.mutation.ReceiveDiff(); ok { + _spec.SetField(materialrequest.FieldReceiveDiff, field.TypeFloat64, value) + } + if value, ok := _u.mutation.AddedReceiveDiff(); ok { + _spec.AddField(materialrequest.FieldReceiveDiff, field.TypeFloat64, value) + } + if _u.mutation.ReceiveDiffCleared() { + _spec.ClearField(materialrequest.FieldReceiveDiff, field.TypeFloat64) + } + if value, ok := _u.mutation.ReceiveNote(); ok { + _spec.SetField(materialrequest.FieldReceiveNote, field.TypeString, value) + } if value, ok := _u.mutation.UpdatedAt(); ok { _spec.SetField(materialrequest.FieldUpdatedAt, field.TypeTime, value) } @@ -1131,6 +1225,74 @@ func (_u *MaterialRequestUpdateOne) SetNillableLossReason(v *string) *MaterialRe return _u } +// SetReceiveQty sets the "receiveQty" field. +func (_u *MaterialRequestUpdateOne) SetReceiveQty(v float64) *MaterialRequestUpdateOne { + _u.mutation.ResetReceiveQty() + _u.mutation.SetReceiveQty(v) + return _u +} + +// SetNillableReceiveQty sets the "receiveQty" field if the given value is not nil. +func (_u *MaterialRequestUpdateOne) SetNillableReceiveQty(v *float64) *MaterialRequestUpdateOne { + if v != nil { + _u.SetReceiveQty(*v) + } + return _u +} + +// AddReceiveQty adds value to the "receiveQty" field. +func (_u *MaterialRequestUpdateOne) AddReceiveQty(v float64) *MaterialRequestUpdateOne { + _u.mutation.AddReceiveQty(v) + return _u +} + +// ClearReceiveQty clears the value of the "receiveQty" field. +func (_u *MaterialRequestUpdateOne) ClearReceiveQty() *MaterialRequestUpdateOne { + _u.mutation.ClearReceiveQty() + return _u +} + +// SetReceiveDiff sets the "receiveDiff" field. +func (_u *MaterialRequestUpdateOne) SetReceiveDiff(v float64) *MaterialRequestUpdateOne { + _u.mutation.ResetReceiveDiff() + _u.mutation.SetReceiveDiff(v) + return _u +} + +// SetNillableReceiveDiff sets the "receiveDiff" field if the given value is not nil. +func (_u *MaterialRequestUpdateOne) SetNillableReceiveDiff(v *float64) *MaterialRequestUpdateOne { + if v != nil { + _u.SetReceiveDiff(*v) + } + return _u +} + +// AddReceiveDiff adds value to the "receiveDiff" field. +func (_u *MaterialRequestUpdateOne) AddReceiveDiff(v float64) *MaterialRequestUpdateOne { + _u.mutation.AddReceiveDiff(v) + return _u +} + +// ClearReceiveDiff clears the value of the "receiveDiff" field. +func (_u *MaterialRequestUpdateOne) ClearReceiveDiff() *MaterialRequestUpdateOne { + _u.mutation.ClearReceiveDiff() + return _u +} + +// SetReceiveNote sets the "receiveNote" field. +func (_u *MaterialRequestUpdateOne) SetReceiveNote(v string) *MaterialRequestUpdateOne { + _u.mutation.SetReceiveNote(v) + return _u +} + +// SetNillableReceiveNote sets the "receiveNote" field if the given value is not nil. +func (_u *MaterialRequestUpdateOne) SetNillableReceiveNote(v *string) *MaterialRequestUpdateOne { + if v != nil { + _u.SetReceiveNote(*v) + } + return _u +} + // SetUpdatedAt sets the "updatedAt" field. func (_u *MaterialRequestUpdateOne) SetUpdatedAt(v time.Time) *MaterialRequestUpdateOne { _u.mutation.SetUpdatedAt(v) @@ -1274,6 +1436,11 @@ func (_u *MaterialRequestUpdateOne) check() error { return &ValidationError{Name: "lossReason", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.lossReason": %w`, err)} } } + if v, ok := _u.mutation.ReceiveNote(); ok { + if err := materialrequest.ReceiveNoteValidator(v); err != nil { + return &ValidationError{Name: "receiveNote", err: fmt.Errorf(`ent: validator failed for field "MaterialRequest.receiveNote": %w`, err)} + } + } return nil } @@ -1417,6 +1584,27 @@ func (_u *MaterialRequestUpdateOne) sqlSave(ctx context.Context) (_node *Materia if value, ok := _u.mutation.LossReason(); ok { _spec.SetField(materialrequest.FieldLossReason, field.TypeString, value) } + if value, ok := _u.mutation.ReceiveQty(); ok { + _spec.SetField(materialrequest.FieldReceiveQty, field.TypeFloat64, value) + } + if value, ok := _u.mutation.AddedReceiveQty(); ok { + _spec.AddField(materialrequest.FieldReceiveQty, field.TypeFloat64, value) + } + if _u.mutation.ReceiveQtyCleared() { + _spec.ClearField(materialrequest.FieldReceiveQty, field.TypeFloat64) + } + if value, ok := _u.mutation.ReceiveDiff(); ok { + _spec.SetField(materialrequest.FieldReceiveDiff, field.TypeFloat64, value) + } + if value, ok := _u.mutation.AddedReceiveDiff(); ok { + _spec.AddField(materialrequest.FieldReceiveDiff, field.TypeFloat64, value) + } + if _u.mutation.ReceiveDiffCleared() { + _spec.ClearField(materialrequest.FieldReceiveDiff, field.TypeFloat64) + } + if value, ok := _u.mutation.ReceiveNote(); ok { + _spec.SetField(materialrequest.FieldReceiveNote, field.TypeString, value) + } if value, ok := _u.mutation.UpdatedAt(); ok { _spec.SetField(materialrequest.FieldUpdatedAt, field.TypeTime, value) } diff --git a/bj_power_mes/ent/migrate/schema.go b/bj_power_mes/ent/migrate/schema.go index d43ee4e..71ab2c3 100644 --- a/bj_power_mes/ent/migrate/schema.go +++ b/bj_power_mes/ent/migrate/schema.go @@ -95,6 +95,23 @@ var ( }, }, } + // AgvVehicleStateColumns holds the columns for the "agv_vehicle_state" table. + AgvVehicleStateColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "agv_code", Type: field.TypeString, Unique: true, Size: 32, Comment: "车辆编号(RCS robotCode/agvCode;RCS 未分车时=DEFAULT 未知车辆)"}, + {Name: "has_pallet", Type: field.TypeBool, Comment: "载货状态:true=有托盘(载货) false=空车", Default: false}, + {Name: "source", Type: field.TypeString, Size: 20, Comment: "状态来源:AUTO_LOAD取货确认/AUTO_UNLOAD卸货确认/MANUAL人工维护", Default: "MANUAL"}, + {Name: "updated_by", Type: field.TypeString, Size: 64, Comment: "最近更新人", Default: ""}, + {Name: "updated_at", Type: field.TypeInt64, Comment: "最近更新时间 unix秒", Default: 0}, + {Name: "remark", Type: field.TypeString, Size: 200, Comment: "备注(人工修改原因等)", Default: ""}, + } + // AgvVehicleStateTable holds the schema information for the "agv_vehicle_state" table. + AgvVehicleStateTable = &schema.Table{ + Name: "agv_vehicle_state", + Comment: "AgvVehicleState AGV 载货状态台账:按 agv_code 逐台记录有托盘/空车,取货/卸货确认与人工维护写入,派车防撞校验消费。", + Columns: AgvVehicleStateColumns, + PrimaryKey: []*schema.Column{AgvVehicleStateColumns[0]}, + } // AlertColumns holds the columns for the "alert" table. AlertColumns = []*schema.Column{ {Name: "id", Type: field.TypeInt, Increment: true}, @@ -371,7 +388,7 @@ var ( // DockTable holds the schema information for the "dock" table. DockTable = &schema.Table{ Name: "dock", - Comment: "Dock 接驳台主数据:DOCK01~DOCK20(产线,DOCKn↔工位n)+ DOCK21(库房收货)。", + Comment: "Dock 接驳台主数据:DOCK01~DOCK20(产线,DOCKn↔工位n)+ JBT21(库房收货;T7 2026-11-03 统一代号)。", Columns: DockColumns, PrimaryKey: []*schema.Column{DockColumns[0]}, Indexes: []*schema.Index{ @@ -438,7 +455,7 @@ var ( {Name: "unit", Type: field.TypeString, Size: 16, Default: ""}, {Name: "sn_mode", Type: field.TypeInt, Default: 2}, {Name: "unit_qty", Type: field.TypeFloat64, Comment: "单台用量", Default: 0}, - {Name: "loss_rate", Type: field.TypeFloat64, Comment: "损耗率%", Default: 0}, + {Name: "loss_rate", Type: field.TypeFloat64, Comment: "损耗率%(仅展示口径,不参与备料计算——R7 2026-11-03 拍板:备料量=工单需求×单台用量,损耗走补料审批)", Default: 0}, {Name: "created_at", Type: field.TypeTime}, } // FlowMaterialTable holds the schema information for the "flow_material" table. @@ -705,6 +722,9 @@ var ( {Name: "theory_qty", Type: field.TypeFloat64, Nullable: true, Comment: "理论应退量(转产/下班退料按 BOM 计算;实际<理论差额=损耗)"}, {Name: "loss_qty", Type: field.TypeFloat64, Nullable: true, Comment: "损耗量(理论应退-实际退回>0 时记录)"}, {Name: "loss_reason", Type: field.TypeString, Size: 200, Comment: "损耗原因(有损耗时必填,主管在损耗台账批注)", Default: ""}, + {Name: "receive_qty", Type: field.TypeFloat64, Nullable: true, Comment: "库管实收量(WMS 确认收货回写)"}, + {Name: "receive_diff", Type: field.TypeFloat64, Nullable: true, Comment: "收货差异=应退-实收(>0 为少收,记待核,不自动进损耗台账)"}, + {Name: "receive_note", Type: field.TypeString, Size: 200, Comment: "收货差异备注(库管填写,说明差异原因)", Default: ""}, {Name: "created_at", Type: field.TypeTime}, {Name: "updated_at", Type: field.TypeTime, Nullable: true}, } @@ -1558,6 +1578,7 @@ var ( Tables = []*schema.Table{ AgvPointTable, AgvTasksTable, + AgvVehicleStateTable, AlertTable, AlertRuleTable, AssociationTraceTable, @@ -1608,6 +1629,9 @@ func init() { AgvTasksTable.Annotation = &entsql.Annotation{ Table: "agv_tasks", } + AgvVehicleStateTable.Annotation = &entsql.Annotation{ + Table: "agv_vehicle_state", + } AlertTable.Annotation = &entsql.Annotation{ Table: "alert", } diff --git a/bj_power_mes/ent/mutation.go b/bj_power_mes/ent/mutation.go index 8a89a42..3765f5d 100644 --- a/bj_power_mes/ent/mutation.go +++ b/bj_power_mes/ent/mutation.go @@ -5,6 +5,7 @@ package ent import ( "bj_power_mes/ent/agvpoint" "bj_power_mes/ent/agvtask" + "bj_power_mes/ent/agvvehiclestate" "bj_power_mes/ent/alert" "bj_power_mes/ent/alertrule" "bj_power_mes/ent/associationtrace" @@ -67,6 +68,7 @@ const ( // Node types. TypeAgvPoint = "AgvPoint" TypeAgvTask = "AgvTask" + TypeAgvVehicleState = "AgvVehicleState" TypeAlert = "Alert" TypeAlertRule = "AlertRule" TypeAssociationTrace = "AssociationTrace" @@ -2224,6 +2226,638 @@ func (m *AgvTaskMutation) ResetEdge(name string) error { return fmt.Errorf("unknown AgvTask edge %s", name) } +// AgvVehicleStateMutation represents an operation that mutates the AgvVehicleState nodes in the graph. +type AgvVehicleStateMutation struct { + config + op Op + typ string + id *int + agv_code *string + has_pallet *bool + source *string + updated_by *string + updated_at *int64 + addupdated_at *int64 + remark *string + clearedFields map[string]struct{} + done bool + oldValue func(context.Context) (*AgvVehicleState, error) + predicates []predicate.AgvVehicleState +} + +var _ ent.Mutation = (*AgvVehicleStateMutation)(nil) + +// agvvehiclestateOption allows management of the mutation configuration using functional options. +type agvvehiclestateOption func(*AgvVehicleStateMutation) + +// newAgvVehicleStateMutation creates new mutation for the AgvVehicleState entity. +func newAgvVehicleStateMutation(c config, op Op, opts ...agvvehiclestateOption) *AgvVehicleStateMutation { + m := &AgvVehicleStateMutation{ + config: c, + op: op, + typ: TypeAgvVehicleState, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withAgvVehicleStateID sets the ID field of the mutation. +func withAgvVehicleStateID(id int) agvvehiclestateOption { + return func(m *AgvVehicleStateMutation) { + var ( + err error + once sync.Once + value *AgvVehicleState + ) + m.oldValue = func(ctx context.Context) (*AgvVehicleState, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().AgvVehicleState.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withAgvVehicleState sets the old AgvVehicleState of the mutation. +func withAgvVehicleState(node *AgvVehicleState) agvvehiclestateOption { + return func(m *AgvVehicleStateMutation) { + m.oldValue = func(context.Context) (*AgvVehicleState, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m AgvVehicleStateMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m AgvVehicleStateMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("ent: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *AgvVehicleStateMutation) ID() (id int, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *AgvVehicleStateMutation) IDs(ctx context.Context) ([]int, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []int{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().AgvVehicleState.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetAgvCode sets the "agv_code" field. +func (m *AgvVehicleStateMutation) SetAgvCode(s string) { + m.agv_code = &s +} + +// AgvCode returns the value of the "agv_code" field in the mutation. +func (m *AgvVehicleStateMutation) AgvCode() (r string, exists bool) { + v := m.agv_code + if v == nil { + return + } + return *v, true +} + +// OldAgvCode returns the old "agv_code" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldAgvCode(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldAgvCode is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldAgvCode requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldAgvCode: %w", err) + } + return oldValue.AgvCode, nil +} + +// ResetAgvCode resets all changes to the "agv_code" field. +func (m *AgvVehicleStateMutation) ResetAgvCode() { + m.agv_code = nil +} + +// SetHasPallet sets the "has_pallet" field. +func (m *AgvVehicleStateMutation) SetHasPallet(b bool) { + m.has_pallet = &b +} + +// HasPallet returns the value of the "has_pallet" field in the mutation. +func (m *AgvVehicleStateMutation) HasPallet() (r bool, exists bool) { + v := m.has_pallet + if v == nil { + return + } + return *v, true +} + +// OldHasPallet returns the old "has_pallet" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldHasPallet(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldHasPallet is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldHasPallet requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldHasPallet: %w", err) + } + return oldValue.HasPallet, nil +} + +// ResetHasPallet resets all changes to the "has_pallet" field. +func (m *AgvVehicleStateMutation) ResetHasPallet() { + m.has_pallet = nil +} + +// SetSource sets the "source" field. +func (m *AgvVehicleStateMutation) SetSource(s string) { + m.source = &s +} + +// Source returns the value of the "source" field in the mutation. +func (m *AgvVehicleStateMutation) Source() (r string, exists bool) { + v := m.source + if v == nil { + return + } + return *v, true +} + +// OldSource returns the old "source" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldSource(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldSource is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldSource requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldSource: %w", err) + } + return oldValue.Source, nil +} + +// ResetSource resets all changes to the "source" field. +func (m *AgvVehicleStateMutation) ResetSource() { + m.source = nil +} + +// SetUpdatedBy sets the "updated_by" field. +func (m *AgvVehicleStateMutation) SetUpdatedBy(s string) { + m.updated_by = &s +} + +// UpdatedBy returns the value of the "updated_by" field in the mutation. +func (m *AgvVehicleStateMutation) UpdatedBy() (r string, exists bool) { + v := m.updated_by + if v == nil { + return + } + return *v, true +} + +// OldUpdatedBy returns the old "updated_by" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldUpdatedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedBy: %w", err) + } + return oldValue.UpdatedBy, nil +} + +// ResetUpdatedBy resets all changes to the "updated_by" field. +func (m *AgvVehicleStateMutation) ResetUpdatedBy() { + m.updated_by = nil +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *AgvVehicleStateMutation) SetUpdatedAt(i int64) { + m.updated_at = &i + m.addupdated_at = nil +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *AgvVehicleStateMutation) UpdatedAt() (r int64, exists bool) { + v := m.updated_at + if v == nil { + return + } + return *v, true +} + +// OldUpdatedAt returns the old "updated_at" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldUpdatedAt(ctx context.Context) (v int64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err) + } + return oldValue.UpdatedAt, nil +} + +// AddUpdatedAt adds i to the "updated_at" field. +func (m *AgvVehicleStateMutation) AddUpdatedAt(i int64) { + if m.addupdated_at != nil { + *m.addupdated_at += i + } else { + m.addupdated_at = &i + } +} + +// AddedUpdatedAt returns the value that was added to the "updated_at" field in this mutation. +func (m *AgvVehicleStateMutation) AddedUpdatedAt() (r int64, exists bool) { + v := m.addupdated_at + if v == nil { + return + } + return *v, true +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *AgvVehicleStateMutation) ResetUpdatedAt() { + m.updated_at = nil + m.addupdated_at = nil +} + +// SetRemark sets the "remark" field. +func (m *AgvVehicleStateMutation) SetRemark(s string) { + m.remark = &s +} + +// Remark returns the value of the "remark" field in the mutation. +func (m *AgvVehicleStateMutation) Remark() (r string, exists bool) { + v := m.remark + if v == nil { + return + } + return *v, true +} + +// OldRemark returns the old "remark" field's value of the AgvVehicleState entity. +// If the AgvVehicleState object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *AgvVehicleStateMutation) OldRemark(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldRemark is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldRemark requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldRemark: %w", err) + } + return oldValue.Remark, nil +} + +// ResetRemark resets all changes to the "remark" field. +func (m *AgvVehicleStateMutation) ResetRemark() { + m.remark = nil +} + +// Where appends a list predicates to the AgvVehicleStateMutation builder. +func (m *AgvVehicleStateMutation) Where(ps ...predicate.AgvVehicleState) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the AgvVehicleStateMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *AgvVehicleStateMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.AgvVehicleState, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *AgvVehicleStateMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *AgvVehicleStateMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (AgvVehicleState). +func (m *AgvVehicleStateMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *AgvVehicleStateMutation) Fields() []string { + fields := make([]string, 0, 6) + if m.agv_code != nil { + fields = append(fields, agvvehiclestate.FieldAgvCode) + } + if m.has_pallet != nil { + fields = append(fields, agvvehiclestate.FieldHasPallet) + } + if m.source != nil { + fields = append(fields, agvvehiclestate.FieldSource) + } + if m.updated_by != nil { + fields = append(fields, agvvehiclestate.FieldUpdatedBy) + } + if m.updated_at != nil { + fields = append(fields, agvvehiclestate.FieldUpdatedAt) + } + if m.remark != nil { + fields = append(fields, agvvehiclestate.FieldRemark) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *AgvVehicleStateMutation) Field(name string) (ent.Value, bool) { + switch name { + case agvvehiclestate.FieldAgvCode: + return m.AgvCode() + case agvvehiclestate.FieldHasPallet: + return m.HasPallet() + case agvvehiclestate.FieldSource: + return m.Source() + case agvvehiclestate.FieldUpdatedBy: + return m.UpdatedBy() + case agvvehiclestate.FieldUpdatedAt: + return m.UpdatedAt() + case agvvehiclestate.FieldRemark: + return m.Remark() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *AgvVehicleStateMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case agvvehiclestate.FieldAgvCode: + return m.OldAgvCode(ctx) + case agvvehiclestate.FieldHasPallet: + return m.OldHasPallet(ctx) + case agvvehiclestate.FieldSource: + return m.OldSource(ctx) + case agvvehiclestate.FieldUpdatedBy: + return m.OldUpdatedBy(ctx) + case agvvehiclestate.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case agvvehiclestate.FieldRemark: + return m.OldRemark(ctx) + } + return nil, fmt.Errorf("unknown AgvVehicleState field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AgvVehicleStateMutation) SetField(name string, value ent.Value) error { + switch name { + case agvvehiclestate.FieldAgvCode: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetAgvCode(v) + return nil + case agvvehiclestate.FieldHasPallet: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetHasPallet(v) + return nil + case agvvehiclestate.FieldSource: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetSource(v) + return nil + case agvvehiclestate.FieldUpdatedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedBy(v) + return nil + case agvvehiclestate.FieldUpdatedAt: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedAt(v) + return nil + case agvvehiclestate.FieldRemark: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetRemark(v) + return nil + } + return fmt.Errorf("unknown AgvVehicleState field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *AgvVehicleStateMutation) AddedFields() []string { + var fields []string + if m.addupdated_at != nil { + fields = append(fields, agvvehiclestate.FieldUpdatedAt) + } + return fields +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *AgvVehicleStateMutation) AddedField(name string) (ent.Value, bool) { + switch name { + case agvvehiclestate.FieldUpdatedAt: + return m.AddedUpdatedAt() + } + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *AgvVehicleStateMutation) AddField(name string, value ent.Value) error { + switch name { + case agvvehiclestate.FieldUpdatedAt: + v, ok := value.(int64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddUpdatedAt(v) + return nil + } + return fmt.Errorf("unknown AgvVehicleState numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *AgvVehicleStateMutation) ClearedFields() []string { + return nil +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *AgvVehicleStateMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *AgvVehicleStateMutation) ClearField(name string) error { + return fmt.Errorf("unknown AgvVehicleState nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *AgvVehicleStateMutation) ResetField(name string) error { + switch name { + case agvvehiclestate.FieldAgvCode: + m.ResetAgvCode() + return nil + case agvvehiclestate.FieldHasPallet: + m.ResetHasPallet() + return nil + case agvvehiclestate.FieldSource: + m.ResetSource() + return nil + case agvvehiclestate.FieldUpdatedBy: + m.ResetUpdatedBy() + return nil + case agvvehiclestate.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case agvvehiclestate.FieldRemark: + m.ResetRemark() + return nil + } + return fmt.Errorf("unknown AgvVehicleState field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *AgvVehicleStateMutation) AddedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *AgvVehicleStateMutation) AddedIDs(name string) []ent.Value { + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *AgvVehicleStateMutation) RemovedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *AgvVehicleStateMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *AgvVehicleStateMutation) ClearedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *AgvVehicleStateMutation) EdgeCleared(name string) bool { + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *AgvVehicleStateMutation) ClearEdge(name string) error { + return fmt.Errorf("unknown AgvVehicleState unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *AgvVehicleStateMutation) ResetEdge(name string) error { + return fmt.Errorf("unknown AgvVehicleState edge %s", name) +} + // AlertMutation represents an operation that mutates the Alert nodes in the graph. type AlertMutation struct { config @@ -18171,6 +18805,11 @@ type MaterialRequestMutation struct { lossQty *float64 addlossQty *float64 lossReason *string + receiveQty *float64 + addreceiveQty *float64 + receiveDiff *float64 + addreceiveDiff *float64 + receiveNote *string createdAt *time.Time updatedAt *time.Time clearedFields map[string]struct{} @@ -19364,6 +20003,182 @@ func (m *MaterialRequestMutation) ResetLossReason() { m.lossReason = nil } +// SetReceiveQty sets the "receiveQty" field. +func (m *MaterialRequestMutation) SetReceiveQty(f float64) { + m.receiveQty = &f + m.addreceiveQty = nil +} + +// ReceiveQty returns the value of the "receiveQty" field in the mutation. +func (m *MaterialRequestMutation) ReceiveQty() (r float64, exists bool) { + v := m.receiveQty + if v == nil { + return + } + return *v, true +} + +// OldReceiveQty returns the old "receiveQty" field's value of the MaterialRequest entity. +// If the MaterialRequest object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *MaterialRequestMutation) OldReceiveQty(ctx context.Context) (v *float64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldReceiveQty is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldReceiveQty requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldReceiveQty: %w", err) + } + return oldValue.ReceiveQty, nil +} + +// AddReceiveQty adds f to the "receiveQty" field. +func (m *MaterialRequestMutation) AddReceiveQty(f float64) { + if m.addreceiveQty != nil { + *m.addreceiveQty += f + } else { + m.addreceiveQty = &f + } +} + +// AddedReceiveQty returns the value that was added to the "receiveQty" field in this mutation. +func (m *MaterialRequestMutation) AddedReceiveQty() (r float64, exists bool) { + v := m.addreceiveQty + if v == nil { + return + } + return *v, true +} + +// ClearReceiveQty clears the value of the "receiveQty" field. +func (m *MaterialRequestMutation) ClearReceiveQty() { + m.receiveQty = nil + m.addreceiveQty = nil + m.clearedFields[materialrequest.FieldReceiveQty] = struct{}{} +} + +// ReceiveQtyCleared returns if the "receiveQty" field was cleared in this mutation. +func (m *MaterialRequestMutation) ReceiveQtyCleared() bool { + _, ok := m.clearedFields[materialrequest.FieldReceiveQty] + return ok +} + +// ResetReceiveQty resets all changes to the "receiveQty" field. +func (m *MaterialRequestMutation) ResetReceiveQty() { + m.receiveQty = nil + m.addreceiveQty = nil + delete(m.clearedFields, materialrequest.FieldReceiveQty) +} + +// SetReceiveDiff sets the "receiveDiff" field. +func (m *MaterialRequestMutation) SetReceiveDiff(f float64) { + m.receiveDiff = &f + m.addreceiveDiff = nil +} + +// ReceiveDiff returns the value of the "receiveDiff" field in the mutation. +func (m *MaterialRequestMutation) ReceiveDiff() (r float64, exists bool) { + v := m.receiveDiff + if v == nil { + return + } + return *v, true +} + +// OldReceiveDiff returns the old "receiveDiff" field's value of the MaterialRequest entity. +// If the MaterialRequest object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *MaterialRequestMutation) OldReceiveDiff(ctx context.Context) (v *float64, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldReceiveDiff is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldReceiveDiff requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldReceiveDiff: %w", err) + } + return oldValue.ReceiveDiff, nil +} + +// AddReceiveDiff adds f to the "receiveDiff" field. +func (m *MaterialRequestMutation) AddReceiveDiff(f float64) { + if m.addreceiveDiff != nil { + *m.addreceiveDiff += f + } else { + m.addreceiveDiff = &f + } +} + +// AddedReceiveDiff returns the value that was added to the "receiveDiff" field in this mutation. +func (m *MaterialRequestMutation) AddedReceiveDiff() (r float64, exists bool) { + v := m.addreceiveDiff + if v == nil { + return + } + return *v, true +} + +// ClearReceiveDiff clears the value of the "receiveDiff" field. +func (m *MaterialRequestMutation) ClearReceiveDiff() { + m.receiveDiff = nil + m.addreceiveDiff = nil + m.clearedFields[materialrequest.FieldReceiveDiff] = struct{}{} +} + +// ReceiveDiffCleared returns if the "receiveDiff" field was cleared in this mutation. +func (m *MaterialRequestMutation) ReceiveDiffCleared() bool { + _, ok := m.clearedFields[materialrequest.FieldReceiveDiff] + return ok +} + +// ResetReceiveDiff resets all changes to the "receiveDiff" field. +func (m *MaterialRequestMutation) ResetReceiveDiff() { + m.receiveDiff = nil + m.addreceiveDiff = nil + delete(m.clearedFields, materialrequest.FieldReceiveDiff) +} + +// SetReceiveNote sets the "receiveNote" field. +func (m *MaterialRequestMutation) SetReceiveNote(s string) { + m.receiveNote = &s +} + +// ReceiveNote returns the value of the "receiveNote" field in the mutation. +func (m *MaterialRequestMutation) ReceiveNote() (r string, exists bool) { + v := m.receiveNote + if v == nil { + return + } + return *v, true +} + +// OldReceiveNote returns the old "receiveNote" field's value of the MaterialRequest entity. +// If the MaterialRequest object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *MaterialRequestMutation) OldReceiveNote(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldReceiveNote is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldReceiveNote requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldReceiveNote: %w", err) + } + return oldValue.ReceiveNote, nil +} + +// ResetReceiveNote resets all changes to the "receiveNote" field. +func (m *MaterialRequestMutation) ResetReceiveNote() { + m.receiveNote = nil +} + // SetCreatedAt sets the "createdAt" field. func (m *MaterialRequestMutation) SetCreatedAt(t time.Time) { m.createdAt = &t @@ -19483,7 +20298,7 @@ func (m *MaterialRequestMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *MaterialRequestMutation) Fields() []string { - fields := make([]string, 0, 27) + fields := make([]string, 0, 30) if m.requestNo != nil { fields = append(fields, materialrequest.FieldRequestNo) } @@ -19559,6 +20374,15 @@ func (m *MaterialRequestMutation) Fields() []string { if m.lossReason != nil { fields = append(fields, materialrequest.FieldLossReason) } + if m.receiveQty != nil { + fields = append(fields, materialrequest.FieldReceiveQty) + } + if m.receiveDiff != nil { + fields = append(fields, materialrequest.FieldReceiveDiff) + } + if m.receiveNote != nil { + fields = append(fields, materialrequest.FieldReceiveNote) + } if m.createdAt != nil { fields = append(fields, materialrequest.FieldCreatedAt) } @@ -19623,6 +20447,12 @@ func (m *MaterialRequestMutation) Field(name string) (ent.Value, bool) { return m.LossQty() case materialrequest.FieldLossReason: return m.LossReason() + case materialrequest.FieldReceiveQty: + return m.ReceiveQty() + case materialrequest.FieldReceiveDiff: + return m.ReceiveDiff() + case materialrequest.FieldReceiveNote: + return m.ReceiveNote() case materialrequest.FieldCreatedAt: return m.CreatedAt() case materialrequest.FieldUpdatedAt: @@ -19686,6 +20516,12 @@ func (m *MaterialRequestMutation) OldField(ctx context.Context, name string) (en return m.OldLossQty(ctx) case materialrequest.FieldLossReason: return m.OldLossReason(ctx) + case materialrequest.FieldReceiveQty: + return m.OldReceiveQty(ctx) + case materialrequest.FieldReceiveDiff: + return m.OldReceiveDiff(ctx) + case materialrequest.FieldReceiveNote: + return m.OldReceiveNote(ctx) case materialrequest.FieldCreatedAt: return m.OldCreatedAt(ctx) case materialrequest.FieldUpdatedAt: @@ -19874,6 +20710,27 @@ func (m *MaterialRequestMutation) SetField(name string, value ent.Value) error { } m.SetLossReason(v) return nil + case materialrequest.FieldReceiveQty: + v, ok := value.(float64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetReceiveQty(v) + return nil + case materialrequest.FieldReceiveDiff: + v, ok := value.(float64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetReceiveDiff(v) + return nil + case materialrequest.FieldReceiveNote: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetReceiveNote(v) + return nil case materialrequest.FieldCreatedAt: v, ok := value.(time.Time) if !ok { @@ -19917,6 +20774,12 @@ func (m *MaterialRequestMutation) AddedFields() []string { if m.addlossQty != nil { fields = append(fields, materialrequest.FieldLossQty) } + if m.addreceiveQty != nil { + fields = append(fields, materialrequest.FieldReceiveQty) + } + if m.addreceiveDiff != nil { + fields = append(fields, materialrequest.FieldReceiveDiff) + } return fields } @@ -19939,6 +20802,10 @@ func (m *MaterialRequestMutation) AddedField(name string) (ent.Value, bool) { return m.AddedTheoryQty() case materialrequest.FieldLossQty: return m.AddedLossQty() + case materialrequest.FieldReceiveQty: + return m.AddedReceiveQty() + case materialrequest.FieldReceiveDiff: + return m.AddedReceiveDiff() } return nil, false } @@ -19997,6 +20864,20 @@ func (m *MaterialRequestMutation) AddField(name string, value ent.Value) error { } m.AddLossQty(v) return nil + case materialrequest.FieldReceiveQty: + v, ok := value.(float64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddReceiveQty(v) + return nil + case materialrequest.FieldReceiveDiff: + v, ok := value.(float64) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddReceiveDiff(v) + return nil } return fmt.Errorf("unknown MaterialRequest numeric field %s", name) } @@ -20014,6 +20895,12 @@ func (m *MaterialRequestMutation) ClearedFields() []string { if m.FieldCleared(materialrequest.FieldLossQty) { fields = append(fields, materialrequest.FieldLossQty) } + if m.FieldCleared(materialrequest.FieldReceiveQty) { + fields = append(fields, materialrequest.FieldReceiveQty) + } + if m.FieldCleared(materialrequest.FieldReceiveDiff) { + fields = append(fields, materialrequest.FieldReceiveDiff) + } if m.FieldCleared(materialrequest.FieldUpdatedAt) { fields = append(fields, materialrequest.FieldUpdatedAt) } @@ -20040,6 +20927,12 @@ func (m *MaterialRequestMutation) ClearField(name string) error { case materialrequest.FieldLossQty: m.ClearLossQty() return nil + case materialrequest.FieldReceiveQty: + m.ClearReceiveQty() + return nil + case materialrequest.FieldReceiveDiff: + m.ClearReceiveDiff() + return nil case materialrequest.FieldUpdatedAt: m.ClearUpdatedAt() return nil @@ -20126,6 +21019,15 @@ func (m *MaterialRequestMutation) ResetField(name string) error { case materialrequest.FieldLossReason: m.ResetLossReason() return nil + case materialrequest.FieldReceiveQty: + m.ResetReceiveQty() + return nil + case materialrequest.FieldReceiveDiff: + m.ResetReceiveDiff() + return nil + case materialrequest.FieldReceiveNote: + m.ResetReceiveNote() + return nil case materialrequest.FieldCreatedAt: m.ResetCreatedAt() return nil diff --git a/bj_power_mes/ent/predicate/predicate.go b/bj_power_mes/ent/predicate/predicate.go index faa2779..79aeebd 100644 --- a/bj_power_mes/ent/predicate/predicate.go +++ b/bj_power_mes/ent/predicate/predicate.go @@ -12,6 +12,9 @@ type AgvPoint func(*sql.Selector) // AgvTask is the predicate function for agvtask builders. type AgvTask func(*sql.Selector) +// AgvVehicleState is the predicate function for agvvehiclestate builders. +type AgvVehicleState func(*sql.Selector) + // Alert is the predicate function for alert builders. type Alert func(*sql.Selector) diff --git a/bj_power_mes/ent/runtime.go b/bj_power_mes/ent/runtime.go index 45087e7..d4686fc 100644 --- a/bj_power_mes/ent/runtime.go +++ b/bj_power_mes/ent/runtime.go @@ -5,6 +5,7 @@ package ent import ( "bj_power_mes/ent/agvpoint" "bj_power_mes/ent/agvtask" + "bj_power_mes/ent/agvvehiclestate" "bj_power_mes/ent/alert" "bj_power_mes/ent/alertrule" "bj_power_mes/ent/associationtrace" @@ -183,6 +184,38 @@ func init() { agvtaskDescCreatedAt := agvtaskFields[18].Descriptor() // agvtask.DefaultCreatedAt holds the default value on creation for the created_at field. agvtask.DefaultCreatedAt = agvtaskDescCreatedAt.Default.(func() int64) + agvvehiclestateFields := schema.AgvVehicleState{}.Fields() + _ = agvvehiclestateFields + // agvvehiclestateDescAgvCode is the schema descriptor for agv_code field. + agvvehiclestateDescAgvCode := agvvehiclestateFields[0].Descriptor() + // agvvehiclestate.AgvCodeValidator is a validator for the "agv_code" field. It is called by the builders before save. + agvvehiclestate.AgvCodeValidator = agvvehiclestateDescAgvCode.Validators[0].(func(string) error) + // agvvehiclestateDescHasPallet is the schema descriptor for has_pallet field. + agvvehiclestateDescHasPallet := agvvehiclestateFields[1].Descriptor() + // agvvehiclestate.DefaultHasPallet holds the default value on creation for the has_pallet field. + agvvehiclestate.DefaultHasPallet = agvvehiclestateDescHasPallet.Default.(bool) + // agvvehiclestateDescSource is the schema descriptor for source field. + agvvehiclestateDescSource := agvvehiclestateFields[2].Descriptor() + // agvvehiclestate.DefaultSource holds the default value on creation for the source field. + agvvehiclestate.DefaultSource = agvvehiclestateDescSource.Default.(string) + // agvvehiclestate.SourceValidator is a validator for the "source" field. It is called by the builders before save. + agvvehiclestate.SourceValidator = agvvehiclestateDescSource.Validators[0].(func(string) error) + // agvvehiclestateDescUpdatedBy is the schema descriptor for updated_by field. + agvvehiclestateDescUpdatedBy := agvvehiclestateFields[3].Descriptor() + // agvvehiclestate.DefaultUpdatedBy holds the default value on creation for the updated_by field. + agvvehiclestate.DefaultUpdatedBy = agvvehiclestateDescUpdatedBy.Default.(string) + // agvvehiclestate.UpdatedByValidator is a validator for the "updated_by" field. It is called by the builders before save. + agvvehiclestate.UpdatedByValidator = agvvehiclestateDescUpdatedBy.Validators[0].(func(string) error) + // agvvehiclestateDescUpdatedAt is the schema descriptor for updated_at field. + agvvehiclestateDescUpdatedAt := agvvehiclestateFields[4].Descriptor() + // agvvehiclestate.DefaultUpdatedAt holds the default value on creation for the updated_at field. + agvvehiclestate.DefaultUpdatedAt = agvvehiclestateDescUpdatedAt.Default.(int64) + // agvvehiclestateDescRemark is the schema descriptor for remark field. + agvvehiclestateDescRemark := agvvehiclestateFields[5].Descriptor() + // agvvehiclestate.DefaultRemark holds the default value on creation for the remark field. + agvvehiclestate.DefaultRemark = agvvehiclestateDescRemark.Default.(string) + // agvvehiclestate.RemarkValidator is a validator for the "remark" field. It is called by the builders before save. + agvvehiclestate.RemarkValidator = agvvehiclestateDescRemark.Validators[0].(func(string) error) alertFields := schema.Alert{}.Fields() _ = alertFields // alertDescRuleId is the schema descriptor for ruleId field. @@ -1241,12 +1274,18 @@ func init() { materialrequest.DefaultLossReason = materialrequestDescLossReason.Default.(string) // materialrequest.LossReasonValidator is a validator for the "lossReason" field. It is called by the builders before save. materialrequest.LossReasonValidator = materialrequestDescLossReason.Validators[0].(func(string) error) + // materialrequestDescReceiveNote is the schema descriptor for receiveNote field. + materialrequestDescReceiveNote := materialrequestFields[28].Descriptor() + // materialrequest.DefaultReceiveNote holds the default value on creation for the receiveNote field. + materialrequest.DefaultReceiveNote = materialrequestDescReceiveNote.Default.(string) + // materialrequest.ReceiveNoteValidator is a validator for the "receiveNote" field. It is called by the builders before save. + materialrequest.ReceiveNoteValidator = materialrequestDescReceiveNote.Validators[0].(func(string) error) // materialrequestDescCreatedAt is the schema descriptor for createdAt field. - materialrequestDescCreatedAt := materialrequestFields[26].Descriptor() + materialrequestDescCreatedAt := materialrequestFields[29].Descriptor() // materialrequest.DefaultCreatedAt holds the default value on creation for the createdAt field. materialrequest.DefaultCreatedAt = materialrequestDescCreatedAt.Default.(func() time.Time) // materialrequestDescUpdatedAt is the schema descriptor for updatedAt field. - materialrequestDescUpdatedAt := materialrequestFields[27].Descriptor() + materialrequestDescUpdatedAt := materialrequestFields[30].Descriptor() // materialrequest.DefaultUpdatedAt holds the default value on creation for the updatedAt field. materialrequest.DefaultUpdatedAt = materialrequestDescUpdatedAt.Default.(func() time.Time) // materialrequest.UpdateDefaultUpdatedAt holds the default value on update for the updatedAt field. diff --git a/bj_power_mes/ent/tx.go b/bj_power_mes/ent/tx.go index 363cc05..7109fee 100644 --- a/bj_power_mes/ent/tx.go +++ b/bj_power_mes/ent/tx.go @@ -16,6 +16,8 @@ type Tx struct { AgvPoint *AgvPointClient // AgvTask is the client for interacting with the AgvTask builders. AgvTask *AgvTaskClient + // AgvVehicleState is the client for interacting with the AgvVehicleState builders. + AgvVehicleState *AgvVehicleStateClient // Alert is the client for interacting with the Alert builders. Alert *AlertClient // AlertRule is the client for interacting with the AlertRule builders. @@ -229,6 +231,7 @@ func (tx *Tx) Client() *Client { func (tx *Tx) init() { tx.AgvPoint = NewAgvPointClient(tx.config) tx.AgvTask = NewAgvTaskClient(tx.config) + tx.AgvVehicleState = NewAgvVehicleStateClient(tx.config) tx.Alert = NewAlertClient(tx.config) tx.AlertRule = NewAlertRuleClient(tx.config) tx.AssociationTrace = NewAssociationTraceClient(tx.config) diff --git a/bj_power_mes/frontend/src/pages/Agv.vue b/bj_power_mes/frontend/src/pages/Agv.vue index 8fb05c0..6f39c50 100644 --- a/bj_power_mes/frontend/src/pages/Agv.vue +++ b/bj_power_mes/frontend/src/pages/Agv.vue @@ -32,10 +32,10 @@ async function loadDocks() { } // 显示层统一(2026-11-03 左右互换拍板):接驳台按 side(操作员朝向 left/right)显示「工位X左/右」; -// 库房接驳台一律显示「库房接驳台」,不显示 DOCK21/JBT21 编号。 +// 库房接驳台一律显示「库房接驳台」,不显示 JBT21 编号(T7 2026-11-03 统一代号)。 const dockCn = (d) => { if (!d) return '—' - if (String(d.dockCode || '') === 'DOCK21') return '库房接驳台' + if (String(d.dockCode || '') === 'JBT21' || String(d.dockCode || '') === 'DOCK21') return '库房接驳台' const s = d.side === 'left' ? '左' : d.side === 'right' ? '右' : '' return `工位${d.stationNo || ''}${s}` } @@ -172,7 +172,7 @@ const mrTotal = ref(0) const mrQuery = reactive({ status: 'SHIPPED' }) const loadingMrs = ref(false) const selected = ref([]) -const sourceDock = ref('DOCK21') +const sourceDock = ref('JBT21') async function loadMrs() { loadingMrs.value = true @@ -324,7 +324,7 @@ async function loadMode() { } catch { /* 忽略 */ } } -onMounted(() => { loadDocks(); loadTasks(); loadMode(); loadAgvPoints(); loadVehicles() }) +onMounted(() => { loadDocks(); loadTasks(); loadMode(); loadAgvPoints(); loadVehicles(); loadVehicleStates() }) // 车辆状态只读(海康 3.1.7,2026-11-03 拍板:纯只读展示,不干预调度) const vehicles = ref([]) @@ -343,13 +343,50 @@ async function loadVehicles() { } const vehicleStateCn = (s) => ({ '4': '空闲', '2': '执行中', '7': '充电', '1': '任务完成', '5': '异常', '3': '异常', '6': '举升中' }[s] || ('状态' + s)) +// 载货状态台账(2026-11-04 防撞补做):取货/卸货确认自动维护,此处提供人工修正入口(留痕操作人/时间) +const vehicleStates = ref([]) +const loadingStates = ref(false) +const manualAgvCode = ref('') +async function loadVehicleStates() { + loadingStates.value = true + try { + const d = await request.get('/agv/vehicle-states') + vehicleStates.value = d?.list || [] + } catch { vehicleStates.value = [] } + loadingStates.value = false +} +async function setVehicleState(row, hasPallet) { + try { + await ElMessageBox.confirm( + `确认把 AGV「${row.agvCode === 'DEFAULT' ? 'DEFAULT(未识别车辆)' : row.agvCode}」载货状态改为「${hasPallet ? '有托盘' : '空车'}」?该状态直接参与派车防撞校验。`, + '修改载货状态', { type: 'warning', confirmButtonText: '确认修改', cancelButtonText: '返回' } + ) + } catch { return } + try { + await request.post('/agv/vehicle-states/set', { agvCode: row.agvCode, hasPallet, remark: '页面人工维护' }, withOperator()) + ElMessage.success('载货状态已更新') + loadVehicleStates() + } catch { /* 拦截器已提示 */ } +} +async function addManualState(hasPallet) { + const code = (manualAgvCode.value || '').trim() + if (!code) { ElMessage.warning('请先填写车辆编号'); return } + try { + await request.post('/agv/vehicle-states/set', { agvCode: code, hasPallet, remark: '页面人工新增/修改' }, withOperator()) + ElMessage.success('载货状态已更新') + manualAgvCode.value = '' + loadVehicleStates() + } catch { /* 拦截器已提示 */ } +} +const stateSourceCn = (s) => ({ AUTO_LOAD: '取货确认', AUTO_UNLOAD: '卸货确认', MANUAL: '人工维护' }[s] || s) + // 切 tab 重新加载对应数据(2026-10-19:lazy 页签切回不 reload,状态/叫料单会停留在旧数据) function onTabChange(name) { if (name === 'docks') loadDocks() else if (name === 'tasks') loadTasks() else if (name === 'dispatch') loadMrs() else if (name === 'points') loadAgvPoints() - else if (name === 'vehicles') loadVehicles() + else if (name === 'vehicles') { loadVehicles(); loadVehicleStates() } } @@ -403,6 +440,41 @@ function onTabChange(name) {
+ + +
+ ● 载货台账:取货确认→置「有托盘」,卸货确认→置「空车」;派车前防撞校验——AGV 载有托盘时不能前往已有托盘的接驳台(可在此人工修正) +
+
+ + 设为有托盘 + 设为空车 +
+ + + + + + + + + + + + + + + + + + + + diff --git a/bj_power_mes/frontend/src/pages/LineManagement.vue b/bj_power_mes/frontend/src/pages/LineManagement.vue index 532b8c3..c33f4a9 100644 --- a/bj_power_mes/frontend/src/pages/LineManagement.vue +++ b/bj_power_mes/frontend/src/pages/LineManagement.vue @@ -117,9 +117,9 @@ const dlg = reactive({ const TYPE_LABEL = { line: '产线', store: '库房', other: '其他' } function typeLabel(t) { return TYPE_LABEL[t] || '其他' } function tagType(t) { return t === 'line' ? 'success' : (t === 'store' ? 'warning' : 'info') } -// 显示层统一(2026-10-17 裁定):库房接驳台一律显示「库房接驳台」,不显示 DOCK21/JBT21 编号 -// (DOCK21 仅作后端映射;PLC 侧对应点位于 PLC 监控页同样只显示「库房接驳台」) -function dockCodeLabel(code) { return String(code || '') === 'DOCK21' ? '库房接驳台' : code || '—' } +// 显示层统一(2026-10-17 裁定):库房接驳台一律显示「库房接驳台」,不显示 JBT21 编号 +// (JBT21 仅作后端映射,T7 2026-11-03 统一代号;PLC 侧对应点位于 PLC 监控页同样只显示「库房接驳台」) +function dockCodeLabel(code) { return String(code || '') === 'JBT21' ? '库房接驳台' : code || '—' } // 接驳台编码格式校验(运行期禁用正则:仅大写字母与数字,长度 2~16)。 function isDockCodeAlnum(code) { diff --git a/bj_power_mes/frontend/src/pages/MaterialRequest.vue b/bj_power_mes/frontend/src/pages/MaterialRequest.vue index cf747e6..7a65f0c 100644 --- a/bj_power_mes/frontend/src/pages/MaterialRequest.vue +++ b/bj_power_mes/frontend/src/pages/MaterialRequest.vue @@ -62,6 +62,19 @@ + + + + + + + diff --git a/bj_power_wms/frontend/src/pages/PreparationList.vue b/bj_power_wms/frontend/src/pages/PreparationList.vue new file mode 100644 index 0000000..73de8c0 --- /dev/null +++ b/bj_power_wms/frontend/src/pages/PreparationList.vue @@ -0,0 +1,176 @@ + + + + + diff --git a/bj_power_wms/frontend/src/pages/ReturnOrder.vue b/bj_power_wms/frontend/src/pages/ReturnOrder.vue index 024a173..619351b 100644 --- a/bj_power_wms/frontend/src/pages/ReturnOrder.vue +++ b/bj_power_wms/frontend/src/pages/ReturnOrder.vue @@ -1,7 +1,7 @@ - + +
diff --git a/bj_power_workstation/frontend/src/api/index.js b/bj_power_workstation/frontend/src/api/index.js index 4901895..2e5b87f 100644 --- a/bj_power_workstation/frontend/src/api/index.js +++ b/bj_power_workstation/frontend/src/api/index.js @@ -112,9 +112,14 @@ export const emergencyCall = (data) => request.post('/api/emergency/call', data) // 数量不符上报:{stationNo, orderNo, sn, materialCode, materialName, planQty, actualQty, cause} export const qtyReport = (data) => request.post('/api/qty-report', data) -// 工位退料:{orderNo, stationNo, sn, materialCode, materialName, spec, qty, unit, reason} +// 工位退料:{orderNo, stationNo, sn, materialCode, materialName, spec, qty, unit, reason, transportMode} export const returnMaterial = (data) => request.post('/api/return-material', data) +// 我的退料单列表(PENDING 可取消)/ 取消退料单 / 余量参考值(2026-11-04 口径定稿) +export const returnList = () => request.get('/api/return-list') +export const returnCancel = (data) => request.post('/api/return-cancel', data) +export const returnReference = () => request.get('/api/return-reference') + // ---------- 在制品 / 0-13 上下线建档完工 / 物料清单领料 / 追溯(代理 MES 内部 API) ---------- // 在制品列表:{stationNo}(>0=停在该工位)/ {scope}(pending=待流转 / end-pending=末端待取件)→ {list} export const getWip = (params) => request.get('/api/wip', { params }) diff --git a/bj_power_workstation/frontend/src/utils/request.js b/bj_power_workstation/frontend/src/utils/request.js index a6900b5..30f22e0 100644 --- a/bj_power_workstation/frontend/src/utils/request.js +++ b/bj_power_workstation/frontend/src/utils/request.js @@ -92,6 +92,11 @@ service.interceptors.response.use( toastError(msg) return Promise.reject(err) } + // 拍板2(2026-11-04):PLC 离线退料需人工强行确认(code=2409)→ 交调用方弹风险确认框,不在此弹 toast + if (d.code === 2409) { + err.code = 2409 + return Promise.reject(err) + } showErrThrottled(err.message) return Promise.reject(err) } diff --git a/bj_power_workstation/frontend/src/views/Main.vue b/bj_power_workstation/frontend/src/views/Main.vue index f4bd652..0a4beeb 100644 --- a/bj_power_workstation/frontend/src/views/Main.vue +++ b/bj_power_workstation/frontend/src/views/Main.vue @@ -67,13 +67,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ 添加一行 +
+ +
+